1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package net.sourceforge.pmd.lang.plsql.ast;
21
22 import java.io.*;
23 import net.sourceforge.pmd.lang.ast.Node;
24 import net.sourceforge.pmd.lang.ast.SimpleCharStream;
25 import net.sourceforge.pmd.lang.ast.TokenMgrError;
26
27 public class PLSQLParserimplements PLSQLParserTreeConstants, PLSQLParserConstants {
28 protected JJTPLSQLParserState jjtree = new JJTPLSQLParserState();
29
30
31
32
33 public static void main(String[] args)
34 throws ParseException {
35
36 PLSQLParser parser = new PLSQLParser(System.in);
37 PLSQLNode node = parser.Input();
38
39 String s;
40 s = "qwerty";
41
42 s = "\u005c"qwerty\u005c"";
43
44 s = "\u005c"qwerty\u005c".uiop";
45
46 s = "\u005c"qwerty\u005c".\u005c"uiop\u005c"";
47
48 }
49
50
51
52
53 public static String canonicalName(String name)
54 {
55 StringBuilder s = null ;
56
57
58 if (null == name) {
59 return name;
60 }
61 else if (-1 == name.indexOf('"') )
62 {
63 name = name.toUpperCase();
64 s = new StringBuilder(name.trim());
65 }
66 else
67 {
68 StringBuilder oldString = new StringBuilder( name.trim().length());
69 s = new StringBuilder(name.trim());
70 boolean quotedCharacter = false ;
71 for (int i=0; i<oldString.length(); i++) {
72 if (oldString.charAt(i) == '"')
73 {
74
75 oldString.deleteCharAt(i);
76 i--;
77
78
79 quotedCharacter = !quotedCharacter ;
80 }
81 else
82 {
83 s.append( quotedCharacter
84 ? s.charAt(i)
85 : Character.toUpperCase(s.charAt(i))
86 );
87 }
88 }
89 }
90 return s.toString();
91 }
92
93
94
95
96
97
98
99
100
101
102
103 final public ASTInput Input() throws ParseException {
104
105 ASTInput jjtn000 = new ASTInput(this, JJTINPUT);
106 boolean jjtc000 = true;
107 jjtree.openNodeScope(jjtn000);
108 try {
109 label_1:
110 while (true) {
111 switch (jj_nt.kind) {
112 case 2:
113 case 3:
114 case 21:
115 case ALTER:
116 case BEGIN:
117 case COLUMN:
118 case COMMENT:
119 case COMMIT:
120 case CONNECT:
121 case CREATE:
122 case DECLARE:
123 case DELETE:
124 case DROP:
125 case EXECUTE:
126 case EXIT:
127 case FUNCTION:
128 case GRANT:
129 case INSERT:
130 case LOCK:
131 case MERGE:
132 case PACKAGE:
133 case PROMPT:
134 case PROCEDURE:
135 case RENAME:
136 case REVOKE:
137 case ROLLBACK:
138 case SAVEPOINT:
139 case SELECT:
140 case SET:
141 case START:
142 case TRIGGER:
143 case TYPE:
144 case SHOW:
145 case SPOOL:
146 case UPDATE:
147 case WITH:
148 case ANALYZE:
149 case ASSOCIATE:
150 case AUDIT:
151 case DDL:
152 case DISASSOCIATE:
153 case NOAUDIT:
154 case TRUNCATE:
155 case ACCEPT:
156 case COPY:
157 case DEFINE:
158 case DISCONNECT:
159 case HOST:
160 case PRINT:
161 case QUIT:
162 case REMARK:
163 case UNDEFINE:
164 case VARIABLE:
165 case WHENEVER:
166 case IDENTIFIER:
167 ;
168 break;
169 default:
170 jj_la1[0] = jj_gen;
171 break label_1;
172 }
173 if (jj_2_1(7)) {
174 PackageSpecification();
175 } else if (jj_2_2(7)) {
176 PackageBody();
177 } else if (jj_2_3(6)) {
178 TypeSpecification();
179 } else if (jj_2_4(6)) {
180 Table();
181 } else if (jj_2_5(6)) {
182 View();
183 } else if (jj_2_6(6)) {
184 TriggerUnit();
185 } else if (jj_2_7(6)) {
186 AlterTrigger();
187 } else if (jj_2_8(6)) {
188 Synonym();
189 } else if (jj_2_9(6)) {
190 Directory();
191 } else if (jj_2_10(6)) {
192 DatabaseLink();
193 } else if (jj_2_11(6)) {
194 Global();
195 } else if (jj_2_12(6)) {
196 DDLCommand();
197 } else if (jj_2_13(2)) {
198 SqlPlusCommand();
199 } else {
200 switch (jj_nt.kind) {
201 case COMMIT:
202 case DELETE:
203 case INSERT:
204 case LOCK:
205 case MERGE:
206 case ROLLBACK:
207 case SAVEPOINT:
208 case SELECT:
209 case UPDATE:
210 case WITH:
211 switch (jj_nt.kind) {
212 case SELECT:
213 jj_consume_token(SELECT);
214 break;
215 case UPDATE:
216 jj_consume_token(UPDATE);
217 break;
218 case INSERT:
219 jj_consume_token(INSERT);
220 break;
221 case DELETE:
222 jj_consume_token(DELETE);
223 break;
224 case COMMIT:
225 jj_consume_token(COMMIT);
226 break;
227 case ROLLBACK:
228 jj_consume_token(ROLLBACK);
229 break;
230 case SAVEPOINT:
231 jj_consume_token(SAVEPOINT);
232 break;
233 case LOCK:
234 jj_consume_token(LOCK);
235 jj_consume_token(TABLE);
236 break;
237 case MERGE:
238 jj_consume_token(MERGE);
239 break;
240 case WITH:
241 jj_consume_token(WITH);
242 break;
243 default:
244 jj_la1[1] = jj_gen;
245 jj_consume_token(-1);
246 throw new ParseException();
247 }
248 SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
249 break;
250 default:
251 jj_la1[2] = jj_gen;
252 jj_consume_token(-1);
253 throw new ParseException();
254 }
255 }
256 label_2:
257 while (true) {
258 switch (jj_nt.kind) {
259 case 1:
260 ;
261 break;
262 default:
263 jj_la1[3] = jj_gen;
264 break label_2;
265 }
266 jj_consume_token(1);
267 }
268 }
269 jj_consume_token(0);
270 jjtree.closeNodeScope(jjtn000, true);
271 jjtc000 = false;
272 {if (true) return jjtn000 ;}
273 } catch (Throwable jjte000) {
274 if (jjtc000) {
275 jjtree.clearNodeScope(jjtn000);
276 jjtc000 = false;
277 } else {
278 jjtree.popNode();
279 }
280 if (jjte000 instanceof RuntimeException) {
281 {if (true) throw (RuntimeException)jjte000;}
282 }
283 if (jjte000 instanceof ParseException) {
284 {if (true) throw (ParseException)jjte000;}
285 }
286 {if (true) throw (Error)jjte000;}
287 } finally {
288 if (jjtc000) {
289 jjtree.closeNodeScope(jjtn000, true);
290 }
291 }
292 throw new Error("Missing return statement in function");
293 }
294
295 final public ASTDDLCommand DDLCommand() throws ParseException {
296
297 ASTDDLCommand jjtn000 = new ASTDDLCommand(this, JJTDDLCOMMAND);
298 boolean jjtc000 = true;
299 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
300 try {
301 simpleNode = DDLEvent();
302 SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
303 jjtree.closeNodeScope(jjtn000, true);
304 jjtc000 = false;
305 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
306 } catch (Throwable jjte000) {
307 if (jjtc000) {
308 jjtree.clearNodeScope(jjtn000);
309 jjtc000 = false;
310 } else {
311 jjtree.popNode();
312 }
313 if (jjte000 instanceof RuntimeException) {
314 {if (true) throw (RuntimeException)jjte000;}
315 }
316 if (jjte000 instanceof ParseException) {
317 {if (true) throw (ParseException)jjte000;}
318 }
319 {if (true) throw (Error)jjte000;}
320 } finally {
321 if (jjtc000) {
322 jjtree.closeNodeScope(jjtn000, true);
323 }
324 }
325 throw new Error("Missing return statement in function");
326 }
327
328 final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
329
330 ASTSqlPlusCommand jjtn000 = new ASTSqlPlusCommand(this, JJTSQLPLUSCOMMAND);
331 boolean jjtc000 = true;
332 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder() ;
333 try {
334 switch (jj_nt.kind) {
335 case 2:
336 jj_consume_token(2);
337 break;
338 case ACCEPT:
339 jj_consume_token(ACCEPT);
340 break;
341 case COLUMN:
342 jj_consume_token(COLUMN);
343 break;
344 case CONNECT:
345 jj_consume_token(CONNECT);
346 break;
347 case COPY:
348 jj_consume_token(COPY);
349 break;
350 case DEFINE:
351 jj_consume_token(DEFINE);
352 break;
353 case DISCONNECT:
354 jj_consume_token(DISCONNECT);
355 break;
356 case EXECUTE:
357 jj_consume_token(EXECUTE);
358 break;
359 case EXIT:
360 jj_consume_token(EXIT);
361 break;
362 case HOST:
363 jj_consume_token(HOST);
364 break;
365 case PRINT:
366 jj_consume_token(PRINT);
367 break;
368 case PROMPT:
369 jj_consume_token(PROMPT);
370 break;
371 case QUIT:
372 jj_consume_token(QUIT);
373 break;
374 case REMARK:
375 jj_consume_token(REMARK);
376 break;
377 case SET:
378 jj_consume_token(SET);
379 break;
380 case SHOW:
381 jj_consume_token(SHOW);
382 break;
383 case SPOOL:
384 jj_consume_token(SPOOL);
385 break;
386 case START:
387 jj_consume_token(START);
388 break;
389 case UNDEFINE:
390 jj_consume_token(UNDEFINE);
391 break;
392 case VARIABLE:
393 jj_consume_token(VARIABLE);
394 break;
395 case WHENEVER:
396 jj_consume_token(WHENEVER);
397 break;
398 case COMMENT:
399 jj_consume_token(COMMENT);
400 break;
401 case GRANT:
402 jj_consume_token(GRANT);
403 break;
404 case REVOKE:
405 jj_consume_token(REVOKE);
406 break;
407 case DROP:
408 jj_consume_token(DROP);
409 break;
410 case IDENTIFIER:
411 jj_consume_token(IDENTIFIER);
412 break;
413 case 3:
414 jj_consume_token(3);
415 jj_consume_token(ATTACH);
416 break;
417 default:
418 jj_la1[4] = jj_gen;
419 jj_consume_token(-1);
420 throw new ParseException();
421 }
422 sb.append(token.image) ; sb.append(" ...") ;
423 Skip2NextTokenOccurrence(EOL);
424 jjtree.closeNodeScope(jjtn000, true);
425 jjtc000 = false;
426 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
427 } catch (Throwable jjte000) {
428 if (jjtc000) {
429 jjtree.clearNodeScope(jjtn000);
430 jjtc000 = false;
431 } else {
432 jjtree.popNode();
433 }
434 if (jjte000 instanceof RuntimeException) {
435 {if (true) throw (RuntimeException)jjte000;}
436 }
437 if (jjte000 instanceof ParseException) {
438 {if (true) throw (ParseException)jjte000;}
439 }
440 {if (true) throw (Error)jjte000;}
441 } finally {
442 if (jjtc000) {
443 jjtree.closeNodeScope(jjtn000, true);
444 }
445 }
446 throw new Error("Missing return statement in function");
447 }
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474 final public ASTGlobal Global() throws ParseException {
475
476 ASTGlobal jjtn000 = new ASTGlobal(this, JJTGLOBAL);
477 boolean jjtc000 = true;
478 jjtree.openNodeScope(jjtn000);
479 try {
480 if (jj_2_14(2147483647)) {
481 label_3:
482 while (true) {
483 switch (jj_nt.kind) {
484 case 21:
485 ;
486 break;
487 default:
488 jj_la1[5] = jj_gen;
489 break label_3;
490 }
491 Label();
492 }
493 Block();
494 jj_consume_token(4);
495 } else if (jj_2_15(4)) {
496 ProgramUnit();
497 } else {
498 jj_consume_token(-1);
499 throw new ParseException();
500 }
501 jjtree.closeNodeScope(jjtn000, true);
502 jjtc000 = false;
503 {if (true) return jjtn000 ;}
504 } catch (Throwable jjte000) {
505 if (jjtc000) {
506 jjtree.clearNodeScope(jjtn000);
507 jjtc000 = false;
508 } else {
509 jjtree.popNode();
510 }
511 if (jjte000 instanceof RuntimeException) {
512 {if (true) throw (RuntimeException)jjte000;}
513 }
514 if (jjte000 instanceof ParseException) {
515 {if (true) throw (ParseException)jjte000;}
516 }
517 {if (true) throw (Error)jjte000;}
518 } finally {
519 if (jjtc000) {
520 jjtree.closeNodeScope(jjtn000, true);
521 }
522 }
523 throw new Error("Missing return statement in function");
524 }
525
526 final public ASTBlock Block() throws ParseException {
527
528 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
529 boolean jjtc000 = true;
530 jjtree.openNodeScope(jjtn000);
531 try {
532 switch (jj_nt.kind) {
533 case DECLARE:
534 jj_consume_token(DECLARE);
535 DeclarativeSection();
536 break;
537 default:
538 jj_la1[6] = jj_gen;
539 ;
540 }
541 jj_consume_token(BEGIN);
542 label_4:
543 while (true) {
544 switch (jj_nt.kind) {
545 case 5:
546 case 16:
547 case 17:
548 case 21:
549 case REPLACE:
550 case DEFINER:
551 case CURRENT_USER:
552 case LANGUAGE:
553 case INLINE:
554 case ADD:
555 case AGGREGATE:
556 case ARRAY:
557 case AT:
558 case ATTRIBUTE:
559 case AUTHID:
560 case BEGIN:
561 case BODY:
562 case BULK:
563 case BYTE:
564 case CASCADE:
565 case CASE:
566 case CLOSE:
567 case COALESCE:
568 case COLLECT:
569 case COLUMN:
570 case COMMENT:
571 case COMMIT:
572 case CONSTRUCTOR:
573 case CONTINUE:
574 case CONVERT:
575 case CURRENT:
576 case CURSOR:
577 case DATA:
578 case DATE:
579 case DAY:
580 case DECLARE:
581 case DELETE:
582 case DISABLE:
583 case EDITIONABLE:
584 case ELEMENT:
585 case ENABLE:
586 case ESCAPE:
587 case EXCEPT:
588 case EXCEPTIONS:
589 case EXECUTE:
590 case EXIT:
591 case EXTERNAL:
592 case EXTENDS:
593 case EXTRACT:
594 case FALSE:
595 case FETCH:
596 case FINAL:
597 case FOR:
598 case FORALL:
599 case FORCE:
600 case FUNCTION:
601 case GLOBAL:
602 case GOTO:
603 case HASH:
604 case HEAP:
605 case HOUR:
606 case IF:
607 case IMMEDIATE:
608 case INDICES:
609 case INDEXTYPE:
610 case INDICATOR:
611 case INSERT:
612 case INSTANTIABLE:
613 case INTERVAL:
614 case INVALIDATE:
615 case ISOLATION:
616 case JAVA:
617 case LEVEL:
618 case LIMIT:
619 case LOCK:
620 case LOOP:
621 case MAP:
622 case MAX:
623 case MEMBER:
624 case MERGE:
625 case MIN:
626 case MINUTE:
627 case MLSLABEL:
628 case MODIFY:
629 case MOD:
630 case MONTH:
631 case NATURAL:
632 case NEW:
633 case NEW_DOT:
634 case NO:
635 case NONEDITIONABLE:
636 case NOT:
637 case NULL:
638 case NULLIF:
639 case OBJECT:
640 case OID:
641 case OPAQUE:
642 case OPEN:
643 case OPERATOR:
644 case ORGANIZATION:
645 case OTHERS:
646 case OVERRIDING:
647 case PACKAGE:
648 case PARTITION:
649 case PIPE:
650 case PRAGMA:
651 case PRESERVE:
652 case PRIVATE:
653 case PROCEDURE:
654 case RAISE:
655 case RANGE:
656 case RAW:
657 case REAL:
658 case RECORD:
659 case REF:
660 case RELEASE:
661 case RELIES_ON:
662 case RENAME:
663 case RESULT:
664 case RETURN:
665 case RETURNING:
666 case REVERSE:
667 case ROLLBACK:
668 case ROW:
669 case ROWS:
670 case ROWID:
671 case ROWNUM:
672 case SAVE:
673 case SAVEPOINT:
674 case SECOND:
675 case SELECT:
676 case SELF:
677 case SET:
678 case SPACE:
679 case SQL:
680 case SQLCODE:
681 case SQLERRM:
682 case STATIC:
683 case SUBTYPE:
684 case SUBSTITUTABLE:
685 case SUCCESSFUL:
686 case SYSDATE:
687 case SYS_REFCURSOR:
688 case TEMPORARY:
689 case TIME:
690 case TIMESTAMP:
691 case TIMEZONE_REGION:
692 case TIMEZONE_ABBR:
693 case TIMEZONE_MINUTE:
694 case TIMEZONE_HOUR:
695 case TRANSACTION:
696 case TRUE:
697 case TYPE:
698 case UNDER:
699 case USING:
700 case WHILE:
701 case YES:
702 case SHOW:
703 case A:
704 case UPDATE:
705 case DOUBLE:
706 case DEC:
707 case PRECISION:
708 case INT:
709 case NUMERIC:
710 case NCHAR:
711 case NVARCHAR2:
712 case STRING:
713 case UROWID:
714 case VARRAY:
715 case VARYING:
716 case BFILE:
717 case BLOB:
718 case CLOB:
719 case NCLOB:
720 case YEAR:
721 case LOCAL:
722 case WITH:
723 case ZONE:
724 case CHARACTER:
725 case AFTER:
726 case BEFORE:
727 case OLD:
728 case PARENT:
729 case CC_IF:
730 case CC_ERROR:
731 case ANALYZE:
732 case ASSOCIATE:
733 case AUDIT:
734 case COMPOUND:
735 case DATABASE:
736 case CALL:
737 case DDL:
738 case DISASSOCIATE:
739 case EACH:
740 case FOLLOWS:
741 case LOGOFF:
742 case LOGON:
743 case NESTED:
744 case NOAUDIT:
745 case SCHEMA:
746 case SERVERERROR:
747 case SHUTDOWN:
748 case STARTUP:
749 case STATEMENT:
750 case STATISTICS:
751 case SUSPEND:
752 case TRUNCATE:
753 case WRAPPED:
754 case LIBRARY:
755 case NAME:
756 case STRUCT:
757 case CONTEXT:
758 case PARAMETERS:
759 case LENGTH:
760 case TDO:
761 case MAXLEN:
762 case CHARSETID:
763 case CHARSETFORM:
764 case ACCEPT:
765 case ACCESSIBLE:
766 case COPY:
767 case DEFINE:
768 case DISCONNECT:
769 case HOST:
770 case PRINT:
771 case QUIT:
772 case REMARK:
773 case UNDEFINE:
774 case VARIABLE:
775 case WHENEVER:
776 case ATTACH:
777 case CAST:
778 case TREAT:
779 case TRIM:
780 case LEFT:
781 case RIGHT:
782 case BOTH:
783 case EMPTY:
784 case MULTISET:
785 case SUBMULTISET:
786 case LEADING:
787 case TRAILING:
788 case CHAR_CS:
789 case NCHAR_CS:
790 case DBTIMEZONE:
791 case SESSIONTIMEZONE:
792 case AUTHENTICATED:
793 case LINK:
794 case SHARED:
795 case DIRECTORY:
796 case USER:
797 case IDENTIFIER:
798 case UNSIGNED_NUMERIC_LITERAL:
799 case CHARACTER_LITERAL:
800 case STRING_LITERAL:
801 case QUOTED_LITERAL:
802 ;
803 break;
804 default:
805 jj_la1[7] = jj_gen;
806 break label_4;
807 }
808 Statement();
809 }
810 switch (jj_nt.kind) {
811 case EXCEPTION:
812 ExceptionHandler();
813 break;
814 default:
815 jj_la1[8] = jj_gen;
816 ;
817 }
818 jj_consume_token(END);
819 switch (jj_nt.kind) {
820 case IDENTIFIER:
821 jj_consume_token(IDENTIFIER);
822 break;
823 default:
824 jj_la1[9] = jj_gen;
825 ;
826 }
827 jjtree.closeNodeScope(jjtn000, true);
828 jjtc000 = false;
829 {if (true) return jjtn000 ;}
830 } catch (Throwable jjte000) {
831 if (jjtc000) {
832 jjtree.clearNodeScope(jjtn000);
833 jjtc000 = false;
834 } else {
835 jjtree.popNode();
836 }
837 if (jjte000 instanceof RuntimeException) {
838 {if (true) throw (RuntimeException)jjte000;}
839 }
840 if (jjte000 instanceof ParseException) {
841 {if (true) throw (ParseException)jjte000;}
842 }
843 {if (true) throw (Error)jjte000;}
844 } finally {
845 if (jjtc000) {
846 jjtree.closeNodeScope(jjtn000, true);
847 }
848 }
849 throw new Error("Missing return statement in function");
850 }
851
852 final public ASTPackageSpecification PackageSpecification() throws ParseException {
853
854 ASTPackageSpecification jjtn000 = new ASTPackageSpecification(this, JJTPACKAGESPECIFICATION);
855 boolean jjtc000 = true;
856 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
857 try {
858 switch (jj_nt.kind) {
859 case CREATE:
860 jj_consume_token(CREATE);
861 switch (jj_nt.kind) {
862 case OR:
863 jj_consume_token(OR);
864 jj_consume_token(REPLACE);
865 break;
866 default:
867 jj_la1[10] = jj_gen;
868 ;
869 }
870 switch (jj_nt.kind) {
871 case EDITIONABLE:
872 case NONEDITIONABLE:
873 switch (jj_nt.kind) {
874 case EDITIONABLE:
875 jj_consume_token(EDITIONABLE);
876 break;
877 case NONEDITIONABLE:
878 jj_consume_token(NONEDITIONABLE);
879 break;
880 default:
881 jj_la1[11] = jj_gen;
882 jj_consume_token(-1);
883 throw new ParseException();
884 }
885 break;
886 default:
887 jj_la1[12] = jj_gen;
888 ;
889 }
890 break;
891 default:
892 jj_la1[13] = jj_gen;
893 ;
894 }
895 jj_consume_token(PACKAGE);
896 simpleNode = ObjectNameDeclaration();
897 label_5:
898 while (true) {
899 switch (jj_nt.kind) {
900 case AUTHID:
901 case ACCESSIBLE:
902 ;
903 break;
904 default:
905 jj_la1[14] = jj_gen;
906 break label_5;
907 }
908 switch (jj_nt.kind) {
909 case AUTHID:
910 jj_consume_token(AUTHID);
911 switch (jj_nt.kind) {
912 case CURRENT_USER:
913 jj_consume_token(CURRENT_USER);
914 break;
915 case DEFINER:
916 jj_consume_token(DEFINER);
917 break;
918 default:
919 jj_la1[15] = jj_gen;
920 jj_consume_token(-1);
921 throw new ParseException();
922 }
923 break;
924 case ACCESSIBLE:
925 AccessibleByClause();
926 break;
927 default:
928 jj_la1[16] = jj_gen;
929 jj_consume_token(-1);
930 throw new ParseException();
931 }
932 }
933 switch (jj_nt.kind) {
934 case WRAPPED:
935 WrappedObject();
936 break;
937 case AS:
938 case IS:
939 switch (jj_nt.kind) {
940 case IS:
941 jj_consume_token(IS);
942 break;
943 case AS:
944 jj_consume_token(AS);
945 break;
946 default:
947 jj_la1[17] = jj_gen;
948 jj_consume_token(-1);
949 throw new ParseException();
950 }
951 DeclarativeSection();
952 jj_consume_token(END);
953 switch (jj_nt.kind) {
954 case REPLACE:
955 case DEFINER:
956 case CURRENT_USER:
957 case SERIALLY_REUSABLE:
958 case RESTRICT_REFERENCES:
959 case EXCEPTION_INIT:
960 case AUTONOMOUS_TRANSACTION:
961 case LANGUAGE:
962 case INLINE:
963 case ADD:
964 case AGGREGATE:
965 case ALL:
966 case ALTER:
967 case AND:
968 case ANY:
969 case ARRAY:
970 case AS:
971 case ASC:
972 case AT:
973 case ATTRIBUTE:
974 case AUTHID:
975 case AVG:
976 case BETWEEN:
977 case BINARY_INTEGER:
978 case BODY:
979 case BOOLEAN:
980 case BULK:
981 case BY:
982 case BYTE:
983 case CASCADE:
984 case CASE:
985 case CHAR:
986 case CHAR_BASE:
987 case CHECK:
988 case CLOSE:
989 case CLUSTER:
990 case COALESCE:
991 case COLLECT:
992 case COLUMN:
993 case COMMENT:
994 case COMMIT:
995 case COMPRESS:
996 case CONNECT:
997 case CONSTANT:
998 case CONSTRUCTOR:
999 case CONTINUE:
1000 case CONVERT:
1001 case CREATE:
1002 case CURRENT:
1003 case CURRVAL:
1004 case CURSOR:
1005 case DATA:
1006 case DATE:
1007 case DAY:
1008 case DECLARE:
1009 case DECIMAL:
1010 case _DEFAULT:
1011 case DELETE:
1012 case DESC:
1013 case DISABLE:
1014 case DISTINCT:
1015 case DO:
1016 case DROP:
1017 case EDITIONABLE:
1018 case ELEMENT:
1019 case ELSE:
1020 case ELSIF:
1021 case ENABLE:
1022 case ESCAPE:
1023 case EXCEPT:
1024 case EXCEPTION:
1025 case EXCEPTIONS:
1026 case EXCLUSIVE:
1027 case EXECUTE:
1028 case EXISTS:
1029 case EXIT:
1030 case EXTERNAL:
1031 case EXTENDS:
1032 case EXTRACT:
1033 case FALSE:
1034 case FETCH:
1035 case FINAL:
1036 case FLOAT:
1037 case FOR:
1038 case FORALL:
1039 case FORCE:
1040 case FROM:
1041 case FUNCTION:
1042 case GLOBAL:
1043 case GOTO:
1044 case GROUP:
1045 case HASH:
1046 case HAVING:
1047 case HEAP:
1048 case HOUR:
1049 case IF:
1050 case IMMEDIATE:
1051 case IN:
1052 case INDEX:
1053 case INDICES:
1054 case INDEXTYPE:
1055 case INDICATOR:
1056 case INSERT:
1057 case INSTANTIABLE:
1058 case INTEGER:
1059 case INTERFACE:
1060 case INTERSECT:
1061 case INTERVAL:
1062 case INTO:
1063 case INVALIDATE:
1064 case IS:
1065 case ISOLATION:
1066 case JAVA:
1067 case LEVEL:
1068 case LIKE:
1069 case LIMIT:
1070 case LIMITED:
1071 case LOCK:
1072 case LONG:
1073 case LOOP:
1074 case MAP:
1075 case MAX:
1076 case MEMBER:
1077 case MERGE:
1078 case MIN:
1079 case MINUS:
1080 case MINUTE:
1081 case MLSLABEL:
1082 case MODIFY:
1083 case MOD:
1084 case MODE:
1085 case MONTH:
1086 case NATURAL:
1087 case NATURALN:
1088 case NEW:
1089 case NEXTVAL:
1090 case NO:
1091 case NOCOPY:
1092 case NONEDITIONABLE:
1093 case NOT:
1094 case NOWAIT:
1095 case NULL:
1096 case NULLIF:
1097 case NUMBER:
1098 case BFILE_BASE:
1099 case BLOB_BASE:
1100 case CLOB_BASE:
1101 case DATE_BASE:
1102 case NUMBER_BASE:
1103 case OBJECT:
1104 case OCIROWID:
1105 case OF:
1106 case OID:
1107 case ON:
1108 case OPAQUE:
1109 case OPEN:
1110 case OPERATOR:
1111 case OPTION:
1112 case OR:
1113 case ORDER:
1114 case ORGANIZATION:
1115 case OTHERS:
1116 case OUT:
1117 case OVERRIDING:
1118 case PACKAGE:
1119 case PARTITION:
1120 case PCTFREE:
1121 case PLS_INTEGER:
1122 case POSITIVE:
1123 case POSITIVEN:
1124 case PRESERVE:
1125 case PRIOR:
1126 case PROMPT:
1127 case PRIVATE:
1128 case PROCEDURE:
1129 case PUBLIC:
1130 case RAISE:
1131 case RANGE:
1132 case RAW:
1133 case REAL:
1134 case RECORD:
1135 case REF:
1136 case RELEASE:
1137 case RELIES_ON:
1138 case RENAME:
1139 case RESULT:
1140 case RETURN:
1141 case RETURNING:
1142 case REVERSE:
1143 case ROLLBACK:
1144 case ROW:
1145 case ROWS:
1146 case ROWID:
1147 case ROWNUM:
1148 case ROWTYPE:
1149 case SAVE:
1150 case SAVEPOINT:
1151 case SECOND:
1152 case SELECT:
1153 case SELF:
1154 case SEPARATE:
1155 case SET:
1156 case SHARE:
1157 case SMALLINT:
1158 case SPACE:
1159 case SQL:
1160 case SQLCODE:
1161 case SQLERRM:
1162 case START:
1163 case STATIC:
1164 case STDDEV:
1165 case SUBTYPE:
1166 case SUBSTITUTABLE:
1167 case SUCCESSFUL:
1168 case SUM:
1169 case SYNONYM:
1170 case SYSDATE:
1171 case SYS_REFCURSOR:
1172 case TABLE:
1173 case TEMPORARY:
1174 case THEN:
1175 case TIME:
1176 case TIMESTAMP:
1177 case TIMEZONE_REGION:
1178 case TIMEZONE_ABBR:
1179 case TIMEZONE_MINUTE:
1180 case TIMEZONE_HOUR:
1181 case TO:
1182 case TRANSACTION:
1183 case TRIGGER:
1184 case TRUE:
1185 case TYPE:
1186 case UI:
1187 case UNDER:
1188 case USING:
1189 case WHILE:
1190 case YES:
1191 case SHOW:
1192 case A:
1193 case UPDATE:
1194 case VARCHAR:
1195 case VARCHAR2:
1196 case DOUBLE:
1197 case DEC:
1198 case PRECISION:
1199 case INT:
1200 case NUMERIC:
1201 case SIGNTYPE:
1202 case NCHAR:
1203 case NVARCHAR2:
1204 case STRING:
1205 case UROWID:
1206 case VARRAY:
1207 case VARYING:
1208 case BFILE:
1209 case BLOB:
1210 case CLOB:
1211 case NCLOB:
1212 case YEAR:
1213 case LOCAL:
1214 case WITH:
1215 case ZONE:
1216 case CHARACTER:
1217 case AFTER:
1218 case BEFORE:
1219 case OLD:
1220 case PARENT:
1221 case ANALYZE:
1222 case ASSOCIATE:
1223 case AUDIT:
1224 case COMPOUND:
1225 case DATABASE:
1226 case CALL:
1227 case DDL:
1228 case DISASSOCIATE:
1229 case EACH:
1230 case FOLLOWS:
1231 case LOGOFF:
1232 case LOGON:
1233 case NESTED:
1234 case NOAUDIT:
1235 case SCHEMA:
1236 case SERVERERROR:
1237 case SHUTDOWN:
1238 case STARTUP:
1239 case STATEMENT:
1240 case STATISTICS:
1241 case SUSPEND:
1242 case TRUNCATE:
1243 case WRAPPED:
1244 case LIBRARY:
1245 case NAME:
1246 case STRUCT:
1247 case CONTEXT:
1248 case PARAMETERS:
1249 case LENGTH:
1250 case TDO:
1251 case MAXLEN:
1252 case CHARSETID:
1253 case CHARSETFORM:
1254 case ACCEPT:
1255 case ACCESSIBLE:
1256 case COPY:
1257 case DEFINE:
1258 case DISCONNECT:
1259 case HOST:
1260 case PRINT:
1261 case QUIT:
1262 case REMARK:
1263 case UNDEFINE:
1264 case VARIABLE:
1265 case WHENEVER:
1266 case ATTACH:
1267 case CAST:
1268 case TREAT:
1269 case TRIM:
1270 case LEFT:
1271 case RIGHT:
1272 case BOTH:
1273 case EMPTY:
1274 case MULTISET:
1275 case SUBMULTISET:
1276 case LEADING:
1277 case TRAILING:
1278 case CHAR_CS:
1279 case NCHAR_CS:
1280 case DBTIMEZONE:
1281 case SESSIONTIMEZONE:
1282 case AUTHENTICATED:
1283 case LINK:
1284 case SHARED:
1285 case DIRECTORY:
1286 case USER:
1287 case IDENTIFIER:
1288 case QUOTED_LITERAL:
1289 case SQLDATA_CLASS:
1290 case CUSTOMDATUM_CLASS:
1291 case ORADATA_CLASS:
1292 case JAVA_INTERFACE_CLASS:
1293 ID();
1294 break;
1295 default:
1296 jj_la1[18] = jj_gen;
1297 ;
1298 }
1299 jj_consume_token(4);
1300 break;
1301 default:
1302 jj_la1[19] = jj_gen;
1303 jj_consume_token(-1);
1304 throw new ParseException();
1305 }
1306 jjtree.closeNodeScope(jjtn000, true);
1307 jjtc000 = false;
1308 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
1309 } catch (Throwable jjte000) {
1310 if (jjtc000) {
1311 jjtree.clearNodeScope(jjtn000);
1312 jjtc000 = false;
1313 } else {
1314 jjtree.popNode();
1315 }
1316 if (jjte000 instanceof RuntimeException) {
1317 {if (true) throw (RuntimeException)jjte000;}
1318 }
1319 if (jjte000 instanceof ParseException) {
1320 {if (true) throw (ParseException)jjte000;}
1321 }
1322 {if (true) throw (Error)jjte000;}
1323 } finally {
1324 if (jjtc000) {
1325 jjtree.closeNodeScope(jjtn000, true);
1326 }
1327 }
1328 throw new Error("Missing return statement in function");
1329 }
1330
1331 final public ASTPackageBody PackageBody() throws ParseException {
1332
1333 ASTPackageBody jjtn000 = new ASTPackageBody(this, JJTPACKAGEBODY);
1334 boolean jjtc000 = true;
1335 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
1336 try {
1337 switch (jj_nt.kind) {
1338 case CREATE:
1339 jj_consume_token(CREATE);
1340 switch (jj_nt.kind) {
1341 case OR:
1342 jj_consume_token(OR);
1343 jj_consume_token(REPLACE);
1344 break;
1345 default:
1346 jj_la1[20] = jj_gen;
1347 ;
1348 }
1349 switch (jj_nt.kind) {
1350 case EDITIONABLE:
1351 case NONEDITIONABLE:
1352 switch (jj_nt.kind) {
1353 case EDITIONABLE:
1354 jj_consume_token(EDITIONABLE);
1355 break;
1356 case NONEDITIONABLE:
1357 jj_consume_token(NONEDITIONABLE);
1358 break;
1359 default:
1360 jj_la1[21] = jj_gen;
1361 jj_consume_token(-1);
1362 throw new ParseException();
1363 }
1364 break;
1365 default:
1366 jj_la1[22] = jj_gen;
1367 ;
1368 }
1369 break;
1370 default:
1371 jj_la1[23] = jj_gen;
1372 ;
1373 }
1374 switch (jj_nt.kind) {
1375 case PACKAGE:
1376 jj_consume_token(PACKAGE);
1377 break;
1378 case TYPE:
1379 jj_consume_token(TYPE);
1380 break;
1381 default:
1382 jj_la1[24] = jj_gen;
1383 jj_consume_token(-1);
1384 throw new ParseException();
1385 }
1386 jj_consume_token(BODY);
1387 simpleNode = ObjectNameDeclaration();
1388 switch (jj_nt.kind) {
1389 case WRAPPED:
1390 WrappedObject();
1391 break;
1392 case AS:
1393 case IS:
1394 switch (jj_nt.kind) {
1395 case IS:
1396 jj_consume_token(IS);
1397 break;
1398 case AS:
1399 jj_consume_token(AS);
1400 break;
1401 default:
1402 jj_la1[25] = jj_gen;
1403 jj_consume_token(-1);
1404 throw new ParseException();
1405 }
1406 DeclarativeSection();
1407 switch (jj_nt.kind) {
1408 case BEGIN:
1409 jj_consume_token(BEGIN);
1410 label_6:
1411 while (true) {
1412 switch (jj_nt.kind) {
1413 case 5:
1414 case 16:
1415 case 17:
1416 case 21:
1417 case REPLACE:
1418 case DEFINER:
1419 case CURRENT_USER:
1420 case LANGUAGE:
1421 case INLINE:
1422 case ADD:
1423 case AGGREGATE:
1424 case ARRAY:
1425 case AT:
1426 case ATTRIBUTE:
1427 case AUTHID:
1428 case BEGIN:
1429 case BODY:
1430 case BULK:
1431 case BYTE:
1432 case CASCADE:
1433 case CASE:
1434 case CLOSE:
1435 case COALESCE:
1436 case COLLECT:
1437 case COLUMN:
1438 case COMMENT:
1439 case COMMIT:
1440 case CONSTRUCTOR:
1441 case CONTINUE:
1442 case CONVERT:
1443 case CURRENT:
1444 case CURSOR:
1445 case DATA:
1446 case DATE:
1447 case DAY:
1448 case DECLARE:
1449 case DELETE:
1450 case DISABLE:
1451 case EDITIONABLE:
1452 case ELEMENT:
1453 case ENABLE:
1454 case ESCAPE:
1455 case EXCEPT:
1456 case EXCEPTIONS:
1457 case EXECUTE:
1458 case EXIT:
1459 case EXTERNAL:
1460 case EXTENDS:
1461 case EXTRACT:
1462 case FALSE:
1463 case FETCH:
1464 case FINAL:
1465 case FOR:
1466 case FORALL:
1467 case FORCE:
1468 case FUNCTION:
1469 case GLOBAL:
1470 case GOTO:
1471 case HASH:
1472 case HEAP:
1473 case HOUR:
1474 case IF:
1475 case IMMEDIATE:
1476 case INDICES:
1477 case INDEXTYPE:
1478 case INDICATOR:
1479 case INSERT:
1480 case INSTANTIABLE:
1481 case INTERVAL:
1482 case INVALIDATE:
1483 case ISOLATION:
1484 case JAVA:
1485 case LEVEL:
1486 case LIMIT:
1487 case LOCK:
1488 case LOOP:
1489 case MAP:
1490 case MAX:
1491 case MEMBER:
1492 case MERGE:
1493 case MIN:
1494 case MINUTE:
1495 case MLSLABEL:
1496 case MODIFY:
1497 case MOD:
1498 case MONTH:
1499 case NATURAL:
1500 case NEW:
1501 case NEW_DOT:
1502 case NO:
1503 case NONEDITIONABLE:
1504 case NOT:
1505 case NULL:
1506 case NULLIF:
1507 case OBJECT:
1508 case OID:
1509 case OPAQUE:
1510 case OPEN:
1511 case OPERATOR:
1512 case ORGANIZATION:
1513 case OTHERS:
1514 case OVERRIDING:
1515 case PACKAGE:
1516 case PARTITION:
1517 case PIPE:
1518 case PRAGMA:
1519 case PRESERVE:
1520 case PRIVATE:
1521 case PROCEDURE:
1522 case RAISE:
1523 case RANGE:
1524 case RAW:
1525 case REAL:
1526 case RECORD:
1527 case REF:
1528 case RELEASE:
1529 case RELIES_ON:
1530 case RENAME:
1531 case RESULT:
1532 case RETURN:
1533 case RETURNING:
1534 case REVERSE:
1535 case ROLLBACK:
1536 case ROW:
1537 case ROWS:
1538 case ROWID:
1539 case ROWNUM:
1540 case SAVE:
1541 case SAVEPOINT:
1542 case SECOND:
1543 case SELECT:
1544 case SELF:
1545 case SET:
1546 case SPACE:
1547 case SQL:
1548 case SQLCODE:
1549 case SQLERRM:
1550 case STATIC:
1551 case SUBTYPE:
1552 case SUBSTITUTABLE:
1553 case SUCCESSFUL:
1554 case SYSDATE:
1555 case SYS_REFCURSOR:
1556 case TEMPORARY:
1557 case TIME:
1558 case TIMESTAMP:
1559 case TIMEZONE_REGION:
1560 case TIMEZONE_ABBR:
1561 case TIMEZONE_MINUTE:
1562 case TIMEZONE_HOUR:
1563 case TRANSACTION:
1564 case TRUE:
1565 case TYPE:
1566 case UNDER:
1567 case USING:
1568 case WHILE:
1569 case YES:
1570 case SHOW:
1571 case A:
1572 case UPDATE:
1573 case DOUBLE:
1574 case DEC:
1575 case PRECISION:
1576 case INT:
1577 case NUMERIC:
1578 case NCHAR:
1579 case NVARCHAR2:
1580 case STRING:
1581 case UROWID:
1582 case VARRAY:
1583 case VARYING:
1584 case BFILE:
1585 case BLOB:
1586 case CLOB:
1587 case NCLOB:
1588 case YEAR:
1589 case LOCAL:
1590 case WITH:
1591 case ZONE:
1592 case CHARACTER:
1593 case AFTER:
1594 case BEFORE:
1595 case OLD:
1596 case PARENT:
1597 case CC_IF:
1598 case CC_ERROR:
1599 case ANALYZE:
1600 case ASSOCIATE:
1601 case AUDIT:
1602 case COMPOUND:
1603 case DATABASE:
1604 case CALL:
1605 case DDL:
1606 case DISASSOCIATE:
1607 case EACH:
1608 case FOLLOWS:
1609 case LOGOFF:
1610 case LOGON:
1611 case NESTED:
1612 case NOAUDIT:
1613 case SCHEMA:
1614 case SERVERERROR:
1615 case SHUTDOWN:
1616 case STARTUP:
1617 case STATEMENT:
1618 case STATISTICS:
1619 case SUSPEND:
1620 case TRUNCATE:
1621 case WRAPPED:
1622 case LIBRARY:
1623 case NAME:
1624 case STRUCT:
1625 case CONTEXT:
1626 case PARAMETERS:
1627 case LENGTH:
1628 case TDO:
1629 case MAXLEN:
1630 case CHARSETID:
1631 case CHARSETFORM:
1632 case ACCEPT:
1633 case ACCESSIBLE:
1634 case COPY:
1635 case DEFINE:
1636 case DISCONNECT:
1637 case HOST:
1638 case PRINT:
1639 case QUIT:
1640 case REMARK:
1641 case UNDEFINE:
1642 case VARIABLE:
1643 case WHENEVER:
1644 case ATTACH:
1645 case CAST:
1646 case TREAT:
1647 case TRIM:
1648 case LEFT:
1649 case RIGHT:
1650 case BOTH:
1651 case EMPTY:
1652 case MULTISET:
1653 case SUBMULTISET:
1654 case LEADING:
1655 case TRAILING:
1656 case CHAR_CS:
1657 case NCHAR_CS:
1658 case DBTIMEZONE:
1659 case SESSIONTIMEZONE:
1660 case AUTHENTICATED:
1661 case LINK:
1662 case SHARED:
1663 case DIRECTORY:
1664 case USER:
1665 case IDENTIFIER:
1666 case UNSIGNED_NUMERIC_LITERAL:
1667 case CHARACTER_LITERAL:
1668 case STRING_LITERAL:
1669 case QUOTED_LITERAL:
1670 ;
1671 break;
1672 default:
1673 jj_la1[26] = jj_gen;
1674 break label_6;
1675 }
1676 Statement();
1677 }
1678 switch (jj_nt.kind) {
1679 case EXCEPTION:
1680 ExceptionHandler();
1681 break;
1682 default:
1683 jj_la1[27] = jj_gen;
1684 ;
1685 }
1686 break;
1687 default:
1688 jj_la1[28] = jj_gen;
1689 ;
1690 }
1691 jj_consume_token(END);
1692 switch (jj_nt.kind) {
1693 case REPLACE:
1694 case DEFINER:
1695 case CURRENT_USER:
1696 case SERIALLY_REUSABLE:
1697 case RESTRICT_REFERENCES:
1698 case EXCEPTION_INIT:
1699 case AUTONOMOUS_TRANSACTION:
1700 case LANGUAGE:
1701 case INLINE:
1702 case ADD:
1703 case AGGREGATE:
1704 case ALL:
1705 case ALTER:
1706 case AND:
1707 case ANY:
1708 case ARRAY:
1709 case AS:
1710 case ASC:
1711 case AT:
1712 case ATTRIBUTE:
1713 case AUTHID:
1714 case AVG:
1715 case BETWEEN:
1716 case BINARY_INTEGER:
1717 case BODY:
1718 case BOOLEAN:
1719 case BULK:
1720 case BY:
1721 case BYTE:
1722 case CASCADE:
1723 case CASE:
1724 case CHAR:
1725 case CHAR_BASE:
1726 case CHECK:
1727 case CLOSE:
1728 case CLUSTER:
1729 case COALESCE:
1730 case COLLECT:
1731 case COLUMN:
1732 case COMMENT:
1733 case COMMIT:
1734 case COMPRESS:
1735 case CONNECT:
1736 case CONSTANT:
1737 case CONSTRUCTOR:
1738 case CONTINUE:
1739 case CONVERT:
1740 case CREATE:
1741 case CURRENT:
1742 case CURRVAL:
1743 case CURSOR:
1744 case DATA:
1745 case DATE:
1746 case DAY:
1747 case DECLARE:
1748 case DECIMAL:
1749 case _DEFAULT:
1750 case DELETE:
1751 case DESC:
1752 case DISABLE:
1753 case DISTINCT:
1754 case DO:
1755 case DROP:
1756 case EDITIONABLE:
1757 case ELEMENT:
1758 case ELSE:
1759 case ELSIF:
1760 case ENABLE:
1761 case ESCAPE:
1762 case EXCEPT:
1763 case EXCEPTION:
1764 case EXCEPTIONS:
1765 case EXCLUSIVE:
1766 case EXECUTE:
1767 case EXISTS:
1768 case EXIT:
1769 case EXTERNAL:
1770 case EXTENDS:
1771 case EXTRACT:
1772 case FALSE:
1773 case FETCH:
1774 case FINAL:
1775 case FLOAT:
1776 case FOR:
1777 case FORALL:
1778 case FORCE:
1779 case FROM:
1780 case FUNCTION:
1781 case GLOBAL:
1782 case GOTO:
1783 case GROUP:
1784 case HASH:
1785 case HAVING:
1786 case HEAP:
1787 case HOUR:
1788 case IF:
1789 case IMMEDIATE:
1790 case IN:
1791 case INDEX:
1792 case INDICES:
1793 case INDEXTYPE:
1794 case INDICATOR:
1795 case INSERT:
1796 case INSTANTIABLE:
1797 case INTEGER:
1798 case INTERFACE:
1799 case INTERSECT:
1800 case INTERVAL:
1801 case INTO:
1802 case INVALIDATE:
1803 case IS:
1804 case ISOLATION:
1805 case JAVA:
1806 case LEVEL:
1807 case LIKE:
1808 case LIMIT:
1809 case LIMITED:
1810 case LOCK:
1811 case LONG:
1812 case LOOP:
1813 case MAP:
1814 case MAX:
1815 case MEMBER:
1816 case MERGE:
1817 case MIN:
1818 case MINUS:
1819 case MINUTE:
1820 case MLSLABEL:
1821 case MODIFY:
1822 case MOD:
1823 case MODE:
1824 case MONTH:
1825 case NATURAL:
1826 case NATURALN:
1827 case NEW:
1828 case NEXTVAL:
1829 case NO:
1830 case NOCOPY:
1831 case NONEDITIONABLE:
1832 case NOT:
1833 case NOWAIT:
1834 case NULL:
1835 case NULLIF:
1836 case NUMBER:
1837 case BFILE_BASE:
1838 case BLOB_BASE:
1839 case CLOB_BASE:
1840 case DATE_BASE:
1841 case NUMBER_BASE:
1842 case OBJECT:
1843 case OCIROWID:
1844 case OF:
1845 case OID:
1846 case ON:
1847 case OPAQUE:
1848 case OPEN:
1849 case OPERATOR:
1850 case OPTION:
1851 case OR:
1852 case ORDER:
1853 case ORGANIZATION:
1854 case OTHERS:
1855 case OUT:
1856 case OVERRIDING:
1857 case PACKAGE:
1858 case PARTITION:
1859 case PCTFREE:
1860 case PLS_INTEGER:
1861 case POSITIVE:
1862 case POSITIVEN:
1863 case PRESERVE:
1864 case PRIOR:
1865 case PROMPT:
1866 case PRIVATE:
1867 case PROCEDURE:
1868 case PUBLIC:
1869 case RAISE:
1870 case RANGE:
1871 case RAW:
1872 case REAL:
1873 case RECORD:
1874 case REF:
1875 case RELEASE:
1876 case RELIES_ON:
1877 case RENAME:
1878 case RESULT:
1879 case RETURN:
1880 case RETURNING:
1881 case REVERSE:
1882 case ROLLBACK:
1883 case ROW:
1884 case ROWS:
1885 case ROWID:
1886 case ROWNUM:
1887 case ROWTYPE:
1888 case SAVE:
1889 case SAVEPOINT:
1890 case SECOND:
1891 case SELECT:
1892 case SELF:
1893 case SEPARATE:
1894 case SET:
1895 case SHARE:
1896 case SMALLINT:
1897 case SPACE:
1898 case SQL:
1899 case SQLCODE:
1900 case SQLERRM:
1901 case START:
1902 case STATIC:
1903 case STDDEV:
1904 case SUBTYPE:
1905 case SUBSTITUTABLE:
1906 case SUCCESSFUL:
1907 case SUM:
1908 case SYNONYM:
1909 case SYSDATE:
1910 case SYS_REFCURSOR:
1911 case TABLE:
1912 case TEMPORARY:
1913 case THEN:
1914 case TIME:
1915 case TIMESTAMP:
1916 case TIMEZONE_REGION:
1917 case TIMEZONE_ABBR:
1918 case TIMEZONE_MINUTE:
1919 case TIMEZONE_HOUR:
1920 case TO:
1921 case TRANSACTION:
1922 case TRIGGER:
1923 case TRUE:
1924 case TYPE:
1925 case UI:
1926 case UNDER:
1927 case USING:
1928 case WHILE:
1929 case YES:
1930 case SHOW:
1931 case A:
1932 case UPDATE:
1933 case VARCHAR:
1934 case VARCHAR2:
1935 case DOUBLE:
1936 case DEC:
1937 case PRECISION:
1938 case INT:
1939 case NUMERIC:
1940 case SIGNTYPE:
1941 case NCHAR:
1942 case NVARCHAR2:
1943 case STRING:
1944 case UROWID:
1945 case VARRAY:
1946 case VARYING:
1947 case BFILE:
1948 case BLOB:
1949 case CLOB:
1950 case NCLOB:
1951 case YEAR:
1952 case LOCAL:
1953 case WITH:
1954 case ZONE:
1955 case CHARACTER:
1956 case AFTER:
1957 case BEFORE:
1958 case OLD:
1959 case PARENT:
1960 case ANALYZE:
1961 case ASSOCIATE:
1962 case AUDIT:
1963 case COMPOUND:
1964 case DATABASE:
1965 case CALL:
1966 case DDL:
1967 case DISASSOCIATE:
1968 case EACH:
1969 case FOLLOWS:
1970 case LOGOFF:
1971 case LOGON:
1972 case NESTED:
1973 case NOAUDIT:
1974 case SCHEMA:
1975 case SERVERERROR:
1976 case SHUTDOWN:
1977 case STARTUP:
1978 case STATEMENT:
1979 case STATISTICS:
1980 case SUSPEND:
1981 case TRUNCATE:
1982 case WRAPPED:
1983 case LIBRARY:
1984 case NAME:
1985 case STRUCT:
1986 case CONTEXT:
1987 case PARAMETERS:
1988 case LENGTH:
1989 case TDO:
1990 case MAXLEN:
1991 case CHARSETID:
1992 case CHARSETFORM:
1993 case ACCEPT:
1994 case ACCESSIBLE:
1995 case COPY:
1996 case DEFINE:
1997 case DISCONNECT:
1998 case HOST:
1999 case PRINT:
2000 case QUIT:
2001 case REMARK:
2002 case UNDEFINE:
2003 case VARIABLE:
2004 case WHENEVER:
2005 case ATTACH:
2006 case CAST:
2007 case TREAT:
2008 case TRIM:
2009 case LEFT:
2010 case RIGHT:
2011 case BOTH:
2012 case EMPTY:
2013 case MULTISET:
2014 case SUBMULTISET:
2015 case LEADING:
2016 case TRAILING:
2017 case CHAR_CS:
2018 case NCHAR_CS:
2019 case DBTIMEZONE:
2020 case SESSIONTIMEZONE:
2021 case AUTHENTICATED:
2022 case LINK:
2023 case SHARED:
2024 case DIRECTORY:
2025 case USER:
2026 case IDENTIFIER:
2027 case QUOTED_LITERAL:
2028 case SQLDATA_CLASS:
2029 case CUSTOMDATUM_CLASS:
2030 case ORADATA_CLASS:
2031 case JAVA_INTERFACE_CLASS:
2032 ID();
2033 break;
2034 default:
2035 jj_la1[29] = jj_gen;
2036 ;
2037 }
2038 jj_consume_token(4);
2039 break;
2040 default:
2041 jj_la1[30] = jj_gen;
2042 jj_consume_token(-1);
2043 throw new ParseException();
2044 }
2045 jjtree.closeNodeScope(jjtn000, true);
2046 jjtc000 = false;
2047 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
2048 } catch (Throwable jjte000) {
2049 if (jjtc000) {
2050 jjtree.clearNodeScope(jjtn000);
2051 jjtc000 = false;
2052 } else {
2053 jjtree.popNode();
2054 }
2055 if (jjte000 instanceof RuntimeException) {
2056 {if (true) throw (RuntimeException)jjte000;}
2057 }
2058 if (jjte000 instanceof ParseException) {
2059 {if (true) throw (ParseException)jjte000;}
2060 }
2061 {if (true) throw (Error)jjte000;}
2062 } finally {
2063 if (jjtc000) {
2064 jjtree.closeNodeScope(jjtn000, true);
2065 }
2066 }
2067 throw new Error("Missing return statement in function");
2068 }
2069
2070 final public ASTDeclarativeUnit DeclarativeUnit() throws ParseException {
2071
2072 ASTDeclarativeUnit jjtn000 = new ASTDeclarativeUnit(this, JJTDECLARATIVEUNIT);
2073 boolean jjtc000 = true;
2074 jjtree.openNodeScope(jjtn000);
2075 try {
2076 switch (jj_nt.kind) {
2077 case PRAGMA:
2078 Pragma();
2079 break;
2080 default:
2081 jj_la1[31] = jj_gen;
2082 if (jj_2_16(2)) {
2083 ExceptionDeclaration();
2084 } else if (jj_2_17(2147483647)) {
2085 SubTypeDefinition();
2086 } else if (jj_2_18(2147483647)) {
2087 ProgramUnit();
2088 } else if (jj_2_19(4)) {
2089 VariableOrConstantDeclaration();
2090 } else if (jj_2_20(2)) {
2091 CursorSpecification();
2092 } else {
2093 switch (jj_nt.kind) {
2094 case CURSOR:
2095 CursorBody();
2096 break;
2097 case IDENTIFIER:
2098 CollectionDeclaration();
2099 break;
2100 case CONSTRUCTOR:
2101 case CREATE:
2102 case FINAL:
2103 case FUNCTION:
2104 case INSTANTIABLE:
2105 case MAP:
2106 case MEMBER:
2107 case NOT:
2108 case ORDER:
2109 case OVERRIDING:
2110 case PROCEDURE:
2111 case STATIC:
2112 MethodDeclaration();
2113 break;
2114 case CC_IF:
2115 CompilationDeclarationFragment();
2116 break;
2117 default:
2118 jj_la1[32] = jj_gen;
2119 jj_consume_token(-1);
2120 throw new ParseException();
2121 }
2122 }
2123 }
2124 jjtree.closeNodeScope(jjtn000, true);
2125 jjtc000 = false;
2126 {if (true) return jjtn000 ;}
2127 } catch (Throwable jjte000) {
2128 if (jjtc000) {
2129 jjtree.clearNodeScope(jjtn000);
2130 jjtc000 = false;
2131 } else {
2132 jjtree.popNode();
2133 }
2134 if (jjte000 instanceof RuntimeException) {
2135 {if (true) throw (RuntimeException)jjte000;}
2136 }
2137 if (jjte000 instanceof ParseException) {
2138 {if (true) throw (ParseException)jjte000;}
2139 }
2140 {if (true) throw (Error)jjte000;}
2141 } finally {
2142 if (jjtc000) {
2143 jjtree.closeNodeScope(jjtn000, true);
2144 }
2145 }
2146 throw new Error("Missing return statement in function");
2147 }
2148
2149 final public ASTDeclarativeSection DeclarativeSection() throws ParseException {
2150
2151 ASTDeclarativeSection jjtn000 = new ASTDeclarativeSection(this, JJTDECLARATIVESECTION);
2152 boolean jjtc000 = true;
2153 jjtree.openNodeScope(jjtn000);
2154 try {
2155 label_7:
2156 while (true) {
2157 switch (jj_nt.kind) {
2158 case REPLACE:
2159 case DEFINER:
2160 case CURRENT_USER:
2161 case SERIALLY_REUSABLE:
2162 case RESTRICT_REFERENCES:
2163 case EXCEPTION_INIT:
2164 case AUTONOMOUS_TRANSACTION:
2165 case LANGUAGE:
2166 case INLINE:
2167 case ADD:
2168 case AGGREGATE:
2169 case ALL:
2170 case ALTER:
2171 case AND:
2172 case ANY:
2173 case ARRAY:
2174 case AS:
2175 case ASC:
2176 case AT:
2177 case ATTRIBUTE:
2178 case AUTHID:
2179 case AVG:
2180 case BETWEEN:
2181 case BINARY_INTEGER:
2182 case BODY:
2183 case BOOLEAN:
2184 case BULK:
2185 case BY:
2186 case BYTE:
2187 case CASCADE:
2188 case CASE:
2189 case CHAR:
2190 case CHAR_BASE:
2191 case CHECK:
2192 case CLOSE:
2193 case CLUSTER:
2194 case COALESCE:
2195 case COLLECT:
2196 case COLUMN:
2197 case COMMENT:
2198 case COMMIT:
2199 case COMPRESS:
2200 case CONNECT:
2201 case CONSTANT:
2202 case CONSTRUCTOR:
2203 case CONTINUE:
2204 case CONVERT:
2205 case CREATE:
2206 case CURRENT:
2207 case CURRVAL:
2208 case CURSOR:
2209 case DATA:
2210 case DATE:
2211 case DAY:
2212 case DECLARE:
2213 case DECIMAL:
2214 case _DEFAULT:
2215 case DELETE:
2216 case DESC:
2217 case DISABLE:
2218 case DISTINCT:
2219 case DO:
2220 case DROP:
2221 case EDITIONABLE:
2222 case ELEMENT:
2223 case ELSE:
2224 case ELSIF:
2225 case ENABLE:
2226 case ESCAPE:
2227 case EXCEPT:
2228 case EXCEPTION:
2229 case EXCEPTIONS:
2230 case EXCLUSIVE:
2231 case EXECUTE:
2232 case EXISTS:
2233 case EXIT:
2234 case EXTERNAL:
2235 case EXTENDS:
2236 case EXTRACT:
2237 case FALSE:
2238 case FETCH:
2239 case FINAL:
2240 case FLOAT:
2241 case FOR:
2242 case FORALL:
2243 case FORCE:
2244 case FROM:
2245 case FUNCTION:
2246 case GLOBAL:
2247 case GOTO:
2248 case GROUP:
2249 case HASH:
2250 case HAVING:
2251 case HEAP:
2252 case HOUR:
2253 case IF:
2254 case IMMEDIATE:
2255 case IN:
2256 case INDEX:
2257 case INDICES:
2258 case INDEXTYPE:
2259 case INDICATOR:
2260 case INSERT:
2261 case INSTANTIABLE:
2262 case INTEGER:
2263 case INTERFACE:
2264 case INTERSECT:
2265 case INTERVAL:
2266 case INTO:
2267 case INVALIDATE:
2268 case IS:
2269 case ISOLATION:
2270 case JAVA:
2271 case LEVEL:
2272 case LIKE:
2273 case LIMIT:
2274 case LIMITED:
2275 case LOCK:
2276 case LONG:
2277 case LOOP:
2278 case MAP:
2279 case MAX:
2280 case MEMBER:
2281 case MERGE:
2282 case MIN:
2283 case MINUS:
2284 case MINUTE:
2285 case MLSLABEL:
2286 case MODIFY:
2287 case MOD:
2288 case MODE:
2289 case MONTH:
2290 case NATURAL:
2291 case NATURALN:
2292 case NEW:
2293 case NEXTVAL:
2294 case NO:
2295 case NOCOPY:
2296 case NONEDITIONABLE:
2297 case NOT:
2298 case NOWAIT:
2299 case NULL:
2300 case NULLIF:
2301 case NUMBER:
2302 case BFILE_BASE:
2303 case BLOB_BASE:
2304 case CLOB_BASE:
2305 case DATE_BASE:
2306 case NUMBER_BASE:
2307 case OBJECT:
2308 case OCIROWID:
2309 case OF:
2310 case OID:
2311 case ON:
2312 case OPAQUE:
2313 case OPEN:
2314 case OPERATOR:
2315 case OPTION:
2316 case OR:
2317 case ORDER:
2318 case ORGANIZATION:
2319 case OTHERS:
2320 case OUT:
2321 case OVERRIDING:
2322 case PACKAGE:
2323 case PARTITION:
2324 case PCTFREE:
2325 case PLS_INTEGER:
2326 case POSITIVE:
2327 case POSITIVEN:
2328 case PRAGMA:
2329 case PRESERVE:
2330 case PRIOR:
2331 case PROMPT:
2332 case PRIVATE:
2333 case PROCEDURE:
2334 case PUBLIC:
2335 case RAISE:
2336 case RANGE:
2337 case RAW:
2338 case REAL:
2339 case RECORD:
2340 case REF:
2341 case RELEASE:
2342 case RELIES_ON:
2343 case RENAME:
2344 case RESULT:
2345 case RETURN:
2346 case RETURNING:
2347 case REVERSE:
2348 case ROLLBACK:
2349 case ROW:
2350 case ROWS:
2351 case ROWID:
2352 case ROWNUM:
2353 case ROWTYPE:
2354 case SAVE:
2355 case SAVEPOINT:
2356 case SECOND:
2357 case SELECT:
2358 case SELF:
2359 case SEPARATE:
2360 case SET:
2361 case SHARE:
2362 case SMALLINT:
2363 case SPACE:
2364 case SQL:
2365 case SQLCODE:
2366 case SQLERRM:
2367 case START:
2368 case STATIC:
2369 case STDDEV:
2370 case SUBTYPE:
2371 case SUBSTITUTABLE:
2372 case SUCCESSFUL:
2373 case SUM:
2374 case SYNONYM:
2375 case SYSDATE:
2376 case SYS_REFCURSOR:
2377 case TABLE:
2378 case TEMPORARY:
2379 case THEN:
2380 case TIME:
2381 case TIMESTAMP:
2382 case TIMEZONE_REGION:
2383 case TIMEZONE_ABBR:
2384 case TIMEZONE_MINUTE:
2385 case TIMEZONE_HOUR:
2386 case TO:
2387 case TRANSACTION:
2388 case TRIGGER:
2389 case TRUE:
2390 case TYPE:
2391 case UI:
2392 case UNDER:
2393 case USING:
2394 case WHILE:
2395 case YES:
2396 case SHOW:
2397 case A:
2398 case UPDATE:
2399 case VARCHAR:
2400 case VARCHAR2:
2401 case DOUBLE:
2402 case DEC:
2403 case PRECISION:
2404 case INT:
2405 case NUMERIC:
2406 case SIGNTYPE:
2407 case NCHAR:
2408 case NVARCHAR2:
2409 case STRING:
2410 case UROWID:
2411 case VARRAY:
2412 case VARYING:
2413 case BFILE:
2414 case BLOB:
2415 case CLOB:
2416 case NCLOB:
2417 case YEAR:
2418 case LOCAL:
2419 case WITH:
2420 case ZONE:
2421 case CHARACTER:
2422 case AFTER:
2423 case BEFORE:
2424 case OLD:
2425 case PARENT:
2426 case CC_IF:
2427 case ANALYZE:
2428 case ASSOCIATE:
2429 case AUDIT:
2430 case COMPOUND:
2431 case DATABASE:
2432 case CALL:
2433 case DDL:
2434 case DISASSOCIATE:
2435 case EACH:
2436 case FOLLOWS:
2437 case LOGOFF:
2438 case LOGON:
2439 case NESTED:
2440 case NOAUDIT:
2441 case SCHEMA:
2442 case SERVERERROR:
2443 case SHUTDOWN:
2444 case STARTUP:
2445 case STATEMENT:
2446 case STATISTICS:
2447 case SUSPEND:
2448 case TRUNCATE:
2449 case WRAPPED:
2450 case LIBRARY:
2451 case NAME:
2452 case STRUCT:
2453 case CONTEXT:
2454 case PARAMETERS:
2455 case LENGTH:
2456 case TDO:
2457 case MAXLEN:
2458 case CHARSETID:
2459 case CHARSETFORM:
2460 case ACCEPT:
2461 case ACCESSIBLE:
2462 case COPY:
2463 case DEFINE:
2464 case DISCONNECT:
2465 case HOST:
2466 case PRINT:
2467 case QUIT:
2468 case REMARK:
2469 case UNDEFINE:
2470 case VARIABLE:
2471 case WHENEVER:
2472 case ATTACH:
2473 case CAST:
2474 case TREAT:
2475 case TRIM:
2476 case LEFT:
2477 case RIGHT:
2478 case BOTH:
2479 case EMPTY:
2480 case MULTISET:
2481 case SUBMULTISET:
2482 case LEADING:
2483 case TRAILING:
2484 case CHAR_CS:
2485 case NCHAR_CS:
2486 case DBTIMEZONE:
2487 case SESSIONTIMEZONE:
2488 case AUTHENTICATED:
2489 case LINK:
2490 case SHARED:
2491 case DIRECTORY:
2492 case USER:
2493 case IDENTIFIER:
2494 case QUOTED_LITERAL:
2495 case SQLDATA_CLASS:
2496 case CUSTOMDATUM_CLASS:
2497 case ORADATA_CLASS:
2498 case JAVA_INTERFACE_CLASS:
2499 ;
2500 break;
2501 default:
2502 jj_la1[33] = jj_gen;
2503 break label_7;
2504 }
2505 DeclarativeUnit();
2506 }
2507 jjtree.closeNodeScope(jjtn000, true);
2508 jjtc000 = false;
2509 {if (true) return jjtn000 ;}
2510 } catch (Throwable jjte000) {
2511 if (jjtc000) {
2512 jjtree.clearNodeScope(jjtn000);
2513 jjtc000 = false;
2514 } else {
2515 jjtree.popNode();
2516 }
2517 if (jjte000 instanceof RuntimeException) {
2518 {if (true) throw (RuntimeException)jjte000;}
2519 }
2520 if (jjte000 instanceof ParseException) {
2521 {if (true) throw (ParseException)jjte000;}
2522 }
2523 {if (true) throw (Error)jjte000;}
2524 } finally {
2525 if (jjtc000) {
2526 jjtree.closeNodeScope(jjtn000, true);
2527 }
2528 }
2529 throw new Error("Missing return statement in function");
2530 }
2531
2532 final public ASTCompilationDeclarationFragment CompilationDeclarationFragment() throws ParseException {
2533
2534 ASTCompilationDeclarationFragment jjtn000 = new ASTCompilationDeclarationFragment(this, JJTCOMPILATIONDECLARATIONFRAGMENT);
2535 boolean jjtc000 = true;
2536 jjtree.openNodeScope(jjtn000);
2537 try {
2538 jj_consume_token(CC_IF);
2539 ConditionalOrExpression();
2540 jj_consume_token(CC_THEN);
2541 label_8:
2542 while (true) {
2543 switch (jj_nt.kind) {
2544 case REPLACE:
2545 case DEFINER:
2546 case CURRENT_USER:
2547 case SERIALLY_REUSABLE:
2548 case RESTRICT_REFERENCES:
2549 case EXCEPTION_INIT:
2550 case AUTONOMOUS_TRANSACTION:
2551 case LANGUAGE:
2552 case INLINE:
2553 case ADD:
2554 case AGGREGATE:
2555 case ALL:
2556 case ALTER:
2557 case AND:
2558 case ANY:
2559 case ARRAY:
2560 case AS:
2561 case ASC:
2562 case AT:
2563 case ATTRIBUTE:
2564 case AUTHID:
2565 case AVG:
2566 case BETWEEN:
2567 case BINARY_INTEGER:
2568 case BODY:
2569 case BOOLEAN:
2570 case BULK:
2571 case BY:
2572 case BYTE:
2573 case CASCADE:
2574 case CASE:
2575 case CHAR:
2576 case CHAR_BASE:
2577 case CHECK:
2578 case CLOSE:
2579 case CLUSTER:
2580 case COALESCE:
2581 case COLLECT:
2582 case COLUMN:
2583 case COMMENT:
2584 case COMMIT:
2585 case COMPRESS:
2586 case CONNECT:
2587 case CONSTANT:
2588 case CONSTRUCTOR:
2589 case CONTINUE:
2590 case CONVERT:
2591 case CREATE:
2592 case CURRENT:
2593 case CURRVAL:
2594 case CURSOR:
2595 case DATA:
2596 case DATE:
2597 case DAY:
2598 case DECLARE:
2599 case DECIMAL:
2600 case _DEFAULT:
2601 case DELETE:
2602 case DESC:
2603 case DISABLE:
2604 case DISTINCT:
2605 case DO:
2606 case DROP:
2607 case EDITIONABLE:
2608 case ELEMENT:
2609 case ELSE:
2610 case ELSIF:
2611 case ENABLE:
2612 case ESCAPE:
2613 case EXCEPT:
2614 case EXCEPTION:
2615 case EXCEPTIONS:
2616 case EXCLUSIVE:
2617 case EXECUTE:
2618 case EXISTS:
2619 case EXIT:
2620 case EXTERNAL:
2621 case EXTENDS:
2622 case EXTRACT:
2623 case FALSE:
2624 case FETCH:
2625 case FINAL:
2626 case FLOAT:
2627 case FOR:
2628 case FORALL:
2629 case FORCE:
2630 case FROM:
2631 case FUNCTION:
2632 case GLOBAL:
2633 case GOTO:
2634 case GROUP:
2635 case HASH:
2636 case HAVING:
2637 case HEAP:
2638 case HOUR:
2639 case IF:
2640 case IMMEDIATE:
2641 case IN:
2642 case INDEX:
2643 case INDICES:
2644 case INDEXTYPE:
2645 case INDICATOR:
2646 case INSERT:
2647 case INSTANTIABLE:
2648 case INTEGER:
2649 case INTERFACE:
2650 case INTERSECT:
2651 case INTERVAL:
2652 case INTO:
2653 case INVALIDATE:
2654 case IS:
2655 case ISOLATION:
2656 case JAVA:
2657 case LEVEL:
2658 case LIKE:
2659 case LIMIT:
2660 case LIMITED:
2661 case LOCK:
2662 case LONG:
2663 case LOOP:
2664 case MAP:
2665 case MAX:
2666 case MEMBER:
2667 case MERGE:
2668 case MIN:
2669 case MINUS:
2670 case MINUTE:
2671 case MLSLABEL:
2672 case MODIFY:
2673 case MOD:
2674 case MODE:
2675 case MONTH:
2676 case NATURAL:
2677 case NATURALN:
2678 case NEW:
2679 case NEXTVAL:
2680 case NO:
2681 case NOCOPY:
2682 case NONEDITIONABLE:
2683 case NOT:
2684 case NOWAIT:
2685 case NULL:
2686 case NULLIF:
2687 case NUMBER:
2688 case BFILE_BASE:
2689 case BLOB_BASE:
2690 case CLOB_BASE:
2691 case DATE_BASE:
2692 case NUMBER_BASE:
2693 case OBJECT:
2694 case OCIROWID:
2695 case OF:
2696 case OID:
2697 case ON:
2698 case OPAQUE:
2699 case OPEN:
2700 case OPERATOR:
2701 case OPTION:
2702 case OR:
2703 case ORDER:
2704 case ORGANIZATION:
2705 case OTHERS:
2706 case OUT:
2707 case OVERRIDING:
2708 case PACKAGE:
2709 case PARTITION:
2710 case PCTFREE:
2711 case PLS_INTEGER:
2712 case POSITIVE:
2713 case POSITIVEN:
2714 case PRAGMA:
2715 case PRESERVE:
2716 case PRIOR:
2717 case PROMPT:
2718 case PRIVATE:
2719 case PROCEDURE:
2720 case PUBLIC:
2721 case RAISE:
2722 case RANGE:
2723 case RAW:
2724 case REAL:
2725 case RECORD:
2726 case REF:
2727 case RELEASE:
2728 case RELIES_ON:
2729 case RENAME:
2730 case RESULT:
2731 case RETURN:
2732 case RETURNING:
2733 case REVERSE:
2734 case ROLLBACK:
2735 case ROW:
2736 case ROWS:
2737 case ROWID:
2738 case ROWNUM:
2739 case ROWTYPE:
2740 case SAVE:
2741 case SAVEPOINT:
2742 case SECOND:
2743 case SELECT:
2744 case SELF:
2745 case SEPARATE:
2746 case SET:
2747 case SHARE:
2748 case SMALLINT:
2749 case SPACE:
2750 case SQL:
2751 case SQLCODE:
2752 case SQLERRM:
2753 case START:
2754 case STATIC:
2755 case STDDEV:
2756 case SUBTYPE:
2757 case SUBSTITUTABLE:
2758 case SUCCESSFUL:
2759 case SUM:
2760 case SYNONYM:
2761 case SYSDATE:
2762 case SYS_REFCURSOR:
2763 case TABLE:
2764 case TEMPORARY:
2765 case THEN:
2766 case TIME:
2767 case TIMESTAMP:
2768 case TIMEZONE_REGION:
2769 case TIMEZONE_ABBR:
2770 case TIMEZONE_MINUTE:
2771 case TIMEZONE_HOUR:
2772 case TO:
2773 case TRANSACTION:
2774 case TRIGGER:
2775 case TRUE:
2776 case TYPE:
2777 case UI:
2778 case UNDER:
2779 case USING:
2780 case WHILE:
2781 case YES:
2782 case SHOW:
2783 case A:
2784 case UPDATE:
2785 case VARCHAR:
2786 case VARCHAR2:
2787 case DOUBLE:
2788 case DEC:
2789 case PRECISION:
2790 case INT:
2791 case NUMERIC:
2792 case SIGNTYPE:
2793 case NCHAR:
2794 case NVARCHAR2:
2795 case STRING:
2796 case UROWID:
2797 case VARRAY:
2798 case VARYING:
2799 case BFILE:
2800 case BLOB:
2801 case CLOB:
2802 case NCLOB:
2803 case YEAR:
2804 case LOCAL:
2805 case WITH:
2806 case ZONE:
2807 case CHARACTER:
2808 case AFTER:
2809 case BEFORE:
2810 case OLD:
2811 case PARENT:
2812 case CC_IF:
2813 case CC_ERROR:
2814 case ANALYZE:
2815 case ASSOCIATE:
2816 case AUDIT:
2817 case COMPOUND:
2818 case DATABASE:
2819 case CALL:
2820 case DDL:
2821 case DISASSOCIATE:
2822 case EACH:
2823 case FOLLOWS:
2824 case LOGOFF:
2825 case LOGON:
2826 case NESTED:
2827 case NOAUDIT:
2828 case SCHEMA:
2829 case SERVERERROR:
2830 case SHUTDOWN:
2831 case STARTUP:
2832 case STATEMENT:
2833 case STATISTICS:
2834 case SUSPEND:
2835 case TRUNCATE:
2836 case WRAPPED:
2837 case LIBRARY:
2838 case NAME:
2839 case STRUCT:
2840 case CONTEXT:
2841 case PARAMETERS:
2842 case LENGTH:
2843 case TDO:
2844 case MAXLEN:
2845 case CHARSETID:
2846 case CHARSETFORM:
2847 case ACCEPT:
2848 case ACCESSIBLE:
2849 case COPY:
2850 case DEFINE:
2851 case DISCONNECT:
2852 case HOST:
2853 case PRINT:
2854 case QUIT:
2855 case REMARK:
2856 case UNDEFINE:
2857 case VARIABLE:
2858 case WHENEVER:
2859 case ATTACH:
2860 case CAST:
2861 case TREAT:
2862 case TRIM:
2863 case LEFT:
2864 case RIGHT:
2865 case BOTH:
2866 case EMPTY:
2867 case MULTISET:
2868 case SUBMULTISET:
2869 case LEADING:
2870 case TRAILING:
2871 case CHAR_CS:
2872 case NCHAR_CS:
2873 case DBTIMEZONE:
2874 case SESSIONTIMEZONE:
2875 case AUTHENTICATED:
2876 case LINK:
2877 case SHARED:
2878 case DIRECTORY:
2879 case USER:
2880 case IDENTIFIER:
2881 case QUOTED_LITERAL:
2882 case SQLDATA_CLASS:
2883 case CUSTOMDATUM_CLASS:
2884 case ORADATA_CLASS:
2885 case JAVA_INTERFACE_CLASS:
2886 ;
2887 break;
2888 default:
2889 jj_la1[34] = jj_gen;
2890 break label_8;
2891 }
2892 switch (jj_nt.kind) {
2893 case REPLACE:
2894 case DEFINER:
2895 case CURRENT_USER:
2896 case SERIALLY_REUSABLE:
2897 case RESTRICT_REFERENCES:
2898 case EXCEPTION_INIT:
2899 case AUTONOMOUS_TRANSACTION:
2900 case LANGUAGE:
2901 case INLINE:
2902 case ADD:
2903 case AGGREGATE:
2904 case ALL:
2905 case ALTER:
2906 case AND:
2907 case ANY:
2908 case ARRAY:
2909 case AS:
2910 case ASC:
2911 case AT:
2912 case ATTRIBUTE:
2913 case AUTHID:
2914 case AVG:
2915 case BETWEEN:
2916 case BINARY_INTEGER:
2917 case BODY:
2918 case BOOLEAN:
2919 case BULK:
2920 case BY:
2921 case BYTE:
2922 case CASCADE:
2923 case CASE:
2924 case CHAR:
2925 case CHAR_BASE:
2926 case CHECK:
2927 case CLOSE:
2928 case CLUSTER:
2929 case COALESCE:
2930 case COLLECT:
2931 case COLUMN:
2932 case COMMENT:
2933 case COMMIT:
2934 case COMPRESS:
2935 case CONNECT:
2936 case CONSTANT:
2937 case CONSTRUCTOR:
2938 case CONTINUE:
2939 case CONVERT:
2940 case CREATE:
2941 case CURRENT:
2942 case CURRVAL:
2943 case CURSOR:
2944 case DATA:
2945 case DATE:
2946 case DAY:
2947 case DECLARE:
2948 case DECIMAL:
2949 case _DEFAULT:
2950 case DELETE:
2951 case DESC:
2952 case DISABLE:
2953 case DISTINCT:
2954 case DO:
2955 case DROP:
2956 case EDITIONABLE:
2957 case ELEMENT:
2958 case ELSE:
2959 case ELSIF:
2960 case ENABLE:
2961 case ESCAPE:
2962 case EXCEPT:
2963 case EXCEPTION:
2964 case EXCEPTIONS:
2965 case EXCLUSIVE:
2966 case EXECUTE:
2967 case EXISTS:
2968 case EXIT:
2969 case EXTERNAL:
2970 case EXTENDS:
2971 case EXTRACT:
2972 case FALSE:
2973 case FETCH:
2974 case FINAL:
2975 case FLOAT:
2976 case FOR:
2977 case FORALL:
2978 case FORCE:
2979 case FROM:
2980 case FUNCTION:
2981 case GLOBAL:
2982 case GOTO:
2983 case GROUP:
2984 case HASH:
2985 case HAVING:
2986 case HEAP:
2987 case HOUR:
2988 case IF:
2989 case IMMEDIATE:
2990 case IN:
2991 case INDEX:
2992 case INDICES:
2993 case INDEXTYPE:
2994 case INDICATOR:
2995 case INSERT:
2996 case INSTANTIABLE:
2997 case INTEGER:
2998 case INTERFACE:
2999 case INTERSECT:
3000 case INTERVAL:
3001 case INTO:
3002 case INVALIDATE:
3003 case IS:
3004 case ISOLATION:
3005 case JAVA:
3006 case LEVEL:
3007 case LIKE:
3008 case LIMIT:
3009 case LIMITED:
3010 case LOCK:
3011 case LONG:
3012 case LOOP:
3013 case MAP:
3014 case MAX:
3015 case MEMBER:
3016 case MERGE:
3017 case MIN:
3018 case MINUS:
3019 case MINUTE:
3020 case MLSLABEL:
3021 case MODIFY:
3022 case MOD:
3023 case MODE:
3024 case MONTH:
3025 case NATURAL:
3026 case NATURALN:
3027 case NEW:
3028 case NEXTVAL:
3029 case NO:
3030 case NOCOPY:
3031 case NONEDITIONABLE:
3032 case NOT:
3033 case NOWAIT:
3034 case NULL:
3035 case NULLIF:
3036 case NUMBER:
3037 case BFILE_BASE:
3038 case BLOB_BASE:
3039 case CLOB_BASE:
3040 case DATE_BASE:
3041 case NUMBER_BASE:
3042 case OBJECT:
3043 case OCIROWID:
3044 case OF:
3045 case OID:
3046 case ON:
3047 case OPAQUE:
3048 case OPEN:
3049 case OPERATOR:
3050 case OPTION:
3051 case OR:
3052 case ORDER:
3053 case ORGANIZATION:
3054 case OTHERS:
3055 case OUT:
3056 case OVERRIDING:
3057 case PACKAGE:
3058 case PARTITION:
3059 case PCTFREE:
3060 case PLS_INTEGER:
3061 case POSITIVE:
3062 case POSITIVEN:
3063 case PRAGMA:
3064 case PRESERVE:
3065 case PRIOR:
3066 case PROMPT:
3067 case PRIVATE:
3068 case PROCEDURE:
3069 case PUBLIC:
3070 case RAISE:
3071 case RANGE:
3072 case RAW:
3073 case REAL:
3074 case RECORD:
3075 case REF:
3076 case RELEASE:
3077 case RELIES_ON:
3078 case RENAME:
3079 case RESULT:
3080 case RETURN:
3081 case RETURNING:
3082 case REVERSE:
3083 case ROLLBACK:
3084 case ROW:
3085 case ROWS:
3086 case ROWID:
3087 case ROWNUM:
3088 case ROWTYPE:
3089 case SAVE:
3090 case SAVEPOINT:
3091 case SECOND:
3092 case SELECT:
3093 case SELF:
3094 case SEPARATE:
3095 case SET:
3096 case SHARE:
3097 case SMALLINT:
3098 case SPACE:
3099 case SQL:
3100 case SQLCODE:
3101 case SQLERRM:
3102 case START:
3103 case STATIC:
3104 case STDDEV:
3105 case SUBTYPE:
3106 case SUBSTITUTABLE:
3107 case SUCCESSFUL:
3108 case SUM:
3109 case SYNONYM:
3110 case SYSDATE:
3111 case SYS_REFCURSOR:
3112 case TABLE:
3113 case TEMPORARY:
3114 case THEN:
3115 case TIME:
3116 case TIMESTAMP:
3117 case TIMEZONE_REGION:
3118 case TIMEZONE_ABBR:
3119 case TIMEZONE_MINUTE:
3120 case TIMEZONE_HOUR:
3121 case TO:
3122 case TRANSACTION:
3123 case TRIGGER:
3124 case TRUE:
3125 case TYPE:
3126 case UI:
3127 case UNDER:
3128 case USING:
3129 case WHILE:
3130 case YES:
3131 case SHOW:
3132 case A:
3133 case UPDATE:
3134 case VARCHAR:
3135 case VARCHAR2:
3136 case DOUBLE:
3137 case DEC:
3138 case PRECISION:
3139 case INT:
3140 case NUMERIC:
3141 case SIGNTYPE:
3142 case NCHAR:
3143 case NVARCHAR2:
3144 case STRING:
3145 case UROWID:
3146 case VARRAY:
3147 case VARYING:
3148 case BFILE:
3149 case BLOB:
3150 case CLOB:
3151 case NCLOB:
3152 case YEAR:
3153 case LOCAL:
3154 case WITH:
3155 case ZONE:
3156 case CHARACTER:
3157 case AFTER:
3158 case BEFORE:
3159 case OLD:
3160 case PARENT:
3161 case CC_IF:
3162 case ANALYZE:
3163 case ASSOCIATE:
3164 case AUDIT:
3165 case COMPOUND:
3166 case DATABASE:
3167 case CALL:
3168 case DDL:
3169 case DISASSOCIATE:
3170 case EACH:
3171 case FOLLOWS:
3172 case LOGOFF:
3173 case LOGON:
3174 case NESTED:
3175 case NOAUDIT:
3176 case SCHEMA:
3177 case SERVERERROR:
3178 case SHUTDOWN:
3179 case STARTUP:
3180 case STATEMENT:
3181 case STATISTICS:
3182 case SUSPEND:
3183 case TRUNCATE:
3184 case WRAPPED:
3185 case LIBRARY:
3186 case NAME:
3187 case STRUCT:
3188 case CONTEXT:
3189 case PARAMETERS:
3190 case LENGTH:
3191 case TDO:
3192 case MAXLEN:
3193 case CHARSETID:
3194 case CHARSETFORM:
3195 case ACCEPT:
3196 case ACCESSIBLE:
3197 case COPY:
3198 case DEFINE:
3199 case DISCONNECT:
3200 case HOST:
3201 case PRINT:
3202 case QUIT:
3203 case REMARK:
3204 case UNDEFINE:
3205 case VARIABLE:
3206 case WHENEVER:
3207 case ATTACH:
3208 case CAST:
3209 case TREAT:
3210 case TRIM:
3211 case LEFT:
3212 case RIGHT:
3213 case BOTH:
3214 case EMPTY:
3215 case MULTISET:
3216 case SUBMULTISET:
3217 case LEADING:
3218 case TRAILING:
3219 case CHAR_CS:
3220 case NCHAR_CS:
3221 case DBTIMEZONE:
3222 case SESSIONTIMEZONE:
3223 case AUTHENTICATED:
3224 case LINK:
3225 case SHARED:
3226 case DIRECTORY:
3227 case USER:
3228 case IDENTIFIER:
3229 case QUOTED_LITERAL:
3230 case SQLDATA_CLASS:
3231 case CUSTOMDATUM_CLASS:
3232 case ORADATA_CLASS:
3233 case JAVA_INTERFACE_CLASS:
3234 DeclarativeUnit();
3235 break;
3236 case CC_ERROR:
3237 jj_consume_token(CC_ERROR);
3238 Expression();
3239 jj_consume_token(CC_END);
3240 break;
3241 default:
3242 jj_la1[35] = jj_gen;
3243 jj_consume_token(-1);
3244 throw new ParseException();
3245 }
3246 }
3247 label_9:
3248 while (true) {
3249 switch (jj_nt.kind) {
3250 case CC_ELSIF:
3251 ;
3252 break;
3253 default:
3254 jj_la1[36] = jj_gen;
3255 break label_9;
3256 }
3257 jj_consume_token(CC_ELSIF);
3258 ConditionalOrExpression();
3259 jj_consume_token(CC_THEN);
3260 label_10:
3261 while (true) {
3262 switch (jj_nt.kind) {
3263 case REPLACE:
3264 case DEFINER:
3265 case CURRENT_USER:
3266 case SERIALLY_REUSABLE:
3267 case RESTRICT_REFERENCES:
3268 case EXCEPTION_INIT:
3269 case AUTONOMOUS_TRANSACTION:
3270 case LANGUAGE:
3271 case INLINE:
3272 case ADD:
3273 case AGGREGATE:
3274 case ALL:
3275 case ALTER:
3276 case AND:
3277 case ANY:
3278 case ARRAY:
3279 case AS:
3280 case ASC:
3281 case AT:
3282 case ATTRIBUTE:
3283 case AUTHID:
3284 case AVG:
3285 case BETWEEN:
3286 case BINARY_INTEGER:
3287 case BODY:
3288 case BOOLEAN:
3289 case BULK:
3290 case BY:
3291 case BYTE:
3292 case CASCADE:
3293 case CASE:
3294 case CHAR:
3295 case CHAR_BASE:
3296 case CHECK:
3297 case CLOSE:
3298 case CLUSTER:
3299 case COALESCE:
3300 case COLLECT:
3301 case COLUMN:
3302 case COMMENT:
3303 case COMMIT:
3304 case COMPRESS:
3305 case CONNECT:
3306 case CONSTANT:
3307 case CONSTRUCTOR:
3308 case CONTINUE:
3309 case CONVERT:
3310 case CREATE:
3311 case CURRENT:
3312 case CURRVAL:
3313 case CURSOR:
3314 case DATA:
3315 case DATE:
3316 case DAY:
3317 case DECLARE:
3318 case DECIMAL:
3319 case _DEFAULT:
3320 case DELETE:
3321 case DESC:
3322 case DISABLE:
3323 case DISTINCT:
3324 case DO:
3325 case DROP:
3326 case EDITIONABLE:
3327 case ELEMENT:
3328 case ELSE:
3329 case ELSIF:
3330 case ENABLE:
3331 case ESCAPE:
3332 case EXCEPT:
3333 case EXCEPTION:
3334 case EXCEPTIONS:
3335 case EXCLUSIVE:
3336 case EXECUTE:
3337 case EXISTS:
3338 case EXIT:
3339 case EXTERNAL:
3340 case EXTENDS:
3341 case EXTRACT:
3342 case FALSE:
3343 case FETCH:
3344 case FINAL:
3345 case FLOAT:
3346 case FOR:
3347 case FORALL:
3348 case FORCE:
3349 case FROM:
3350 case FUNCTION:
3351 case GLOBAL:
3352 case GOTO:
3353 case GROUP:
3354 case HASH:
3355 case HAVING:
3356 case HEAP:
3357 case HOUR:
3358 case IF:
3359 case IMMEDIATE:
3360 case IN:
3361 case INDEX:
3362 case INDICES:
3363 case INDEXTYPE:
3364 case INDICATOR:
3365 case INSERT:
3366 case INSTANTIABLE:
3367 case INTEGER:
3368 case INTERFACE:
3369 case INTERSECT:
3370 case INTERVAL:
3371 case INTO:
3372 case INVALIDATE:
3373 case IS:
3374 case ISOLATION:
3375 case JAVA:
3376 case LEVEL:
3377 case LIKE:
3378 case LIMIT:
3379 case LIMITED:
3380 case LOCK:
3381 case LONG:
3382 case LOOP:
3383 case MAP:
3384 case MAX:
3385 case MEMBER:
3386 case MERGE:
3387 case MIN:
3388 case MINUS:
3389 case MINUTE:
3390 case MLSLABEL:
3391 case MODIFY:
3392 case MOD:
3393 case MODE:
3394 case MONTH:
3395 case NATURAL:
3396 case NATURALN:
3397 case NEW:
3398 case NEXTVAL:
3399 case NO:
3400 case NOCOPY:
3401 case NONEDITIONABLE:
3402 case NOT:
3403 case NOWAIT:
3404 case NULL:
3405 case NULLIF:
3406 case NUMBER:
3407 case BFILE_BASE:
3408 case BLOB_BASE:
3409 case CLOB_BASE:
3410 case DATE_BASE:
3411 case NUMBER_BASE:
3412 case OBJECT:
3413 case OCIROWID:
3414 case OF:
3415 case OID:
3416 case ON:
3417 case OPAQUE:
3418 case OPEN:
3419 case OPERATOR:
3420 case OPTION:
3421 case OR:
3422 case ORDER:
3423 case ORGANIZATION:
3424 case OTHERS:
3425 case OUT:
3426 case OVERRIDING:
3427 case PACKAGE:
3428 case PARTITION:
3429 case PCTFREE:
3430 case PLS_INTEGER:
3431 case POSITIVE:
3432 case POSITIVEN:
3433 case PRAGMA:
3434 case PRESERVE:
3435 case PRIOR:
3436 case PROMPT:
3437 case PRIVATE:
3438 case PROCEDURE:
3439 case PUBLIC:
3440 case RAISE:
3441 case RANGE:
3442 case RAW:
3443 case REAL:
3444 case RECORD:
3445 case REF:
3446 case RELEASE:
3447 case RELIES_ON:
3448 case RENAME:
3449 case RESULT:
3450 case RETURN:
3451 case RETURNING:
3452 case REVERSE:
3453 case ROLLBACK:
3454 case ROW:
3455 case ROWS:
3456 case ROWID:
3457 case ROWNUM:
3458 case ROWTYPE:
3459 case SAVE:
3460 case SAVEPOINT:
3461 case SECOND:
3462 case SELECT:
3463 case SELF:
3464 case SEPARATE:
3465 case SET:
3466 case SHARE:
3467 case SMALLINT:
3468 case SPACE:
3469 case SQL:
3470 case SQLCODE:
3471 case SQLERRM:
3472 case START:
3473 case STATIC:
3474 case STDDEV:
3475 case SUBTYPE:
3476 case SUBSTITUTABLE:
3477 case SUCCESSFUL:
3478 case SUM:
3479 case SYNONYM:
3480 case SYSDATE:
3481 case SYS_REFCURSOR:
3482 case TABLE:
3483 case TEMPORARY:
3484 case THEN:
3485 case TIME:
3486 case TIMESTAMP:
3487 case TIMEZONE_REGION:
3488 case TIMEZONE_ABBR:
3489 case TIMEZONE_MINUTE:
3490 case TIMEZONE_HOUR:
3491 case TO:
3492 case TRANSACTION:
3493 case TRIGGER:
3494 case TRUE:
3495 case TYPE:
3496 case UI:
3497 case UNDER:
3498 case USING:
3499 case WHILE:
3500 case YES:
3501 case SHOW:
3502 case A:
3503 case UPDATE:
3504 case VARCHAR:
3505 case VARCHAR2:
3506 case DOUBLE:
3507 case DEC:
3508 case PRECISION:
3509 case INT:
3510 case NUMERIC:
3511 case SIGNTYPE:
3512 case NCHAR:
3513 case NVARCHAR2:
3514 case STRING:
3515 case UROWID:
3516 case VARRAY:
3517 case VARYING:
3518 case BFILE:
3519 case BLOB:
3520 case CLOB:
3521 case NCLOB:
3522 case YEAR:
3523 case LOCAL:
3524 case WITH:
3525 case ZONE:
3526 case CHARACTER:
3527 case AFTER:
3528 case BEFORE:
3529 case OLD:
3530 case PARENT:
3531 case CC_IF:
3532 case CC_ERROR:
3533 case ANALYZE:
3534 case ASSOCIATE:
3535 case AUDIT:
3536 case COMPOUND:
3537 case DATABASE:
3538 case CALL:
3539 case DDL:
3540 case DISASSOCIATE:
3541 case EACH:
3542 case FOLLOWS:
3543 case LOGOFF:
3544 case LOGON:
3545 case NESTED:
3546 case NOAUDIT:
3547 case SCHEMA:
3548 case SERVERERROR:
3549 case SHUTDOWN:
3550 case STARTUP:
3551 case STATEMENT:
3552 case STATISTICS:
3553 case SUSPEND:
3554 case TRUNCATE:
3555 case WRAPPED:
3556 case LIBRARY:
3557 case NAME:
3558 case STRUCT:
3559 case CONTEXT:
3560 case PARAMETERS:
3561 case LENGTH:
3562 case TDO:
3563 case MAXLEN:
3564 case CHARSETID:
3565 case CHARSETFORM:
3566 case ACCEPT:
3567 case ACCESSIBLE:
3568 case COPY:
3569 case DEFINE:
3570 case DISCONNECT:
3571 case HOST:
3572 case PRINT:
3573 case QUIT:
3574 case REMARK:
3575 case UNDEFINE:
3576 case VARIABLE:
3577 case WHENEVER:
3578 case ATTACH:
3579 case CAST:
3580 case TREAT:
3581 case TRIM:
3582 case LEFT:
3583 case RIGHT:
3584 case BOTH:
3585 case EMPTY:
3586 case MULTISET:
3587 case SUBMULTISET:
3588 case LEADING:
3589 case TRAILING:
3590 case CHAR_CS:
3591 case NCHAR_CS:
3592 case DBTIMEZONE:
3593 case SESSIONTIMEZONE:
3594 case AUTHENTICATED:
3595 case LINK:
3596 case SHARED:
3597 case DIRECTORY:
3598 case USER:
3599 case IDENTIFIER:
3600 case QUOTED_LITERAL:
3601 case SQLDATA_CLASS:
3602 case CUSTOMDATUM_CLASS:
3603 case ORADATA_CLASS:
3604 case JAVA_INTERFACE_CLASS:
3605 ;
3606 break;
3607 default:
3608 jj_la1[37] = jj_gen;
3609 break label_10;
3610 }
3611 switch (jj_nt.kind) {
3612 case REPLACE:
3613 case DEFINER:
3614 case CURRENT_USER:
3615 case SERIALLY_REUSABLE:
3616 case RESTRICT_REFERENCES:
3617 case EXCEPTION_INIT:
3618 case AUTONOMOUS_TRANSACTION:
3619 case LANGUAGE:
3620 case INLINE:
3621 case ADD:
3622 case AGGREGATE:
3623 case ALL:
3624 case ALTER:
3625 case AND:
3626 case ANY:
3627 case ARRAY:
3628 case AS:
3629 case ASC:
3630 case AT:
3631 case ATTRIBUTE:
3632 case AUTHID:
3633 case AVG:
3634 case BETWEEN:
3635 case BINARY_INTEGER:
3636 case BODY:
3637 case BOOLEAN:
3638 case BULK:
3639 case BY:
3640 case BYTE:
3641 case CASCADE:
3642 case CASE:
3643 case CHAR:
3644 case CHAR_BASE:
3645 case CHECK:
3646 case CLOSE:
3647 case CLUSTER:
3648 case COALESCE:
3649 case COLLECT:
3650 case COLUMN:
3651 case COMMENT:
3652 case COMMIT:
3653 case COMPRESS:
3654 case CONNECT:
3655 case CONSTANT:
3656 case CONSTRUCTOR:
3657 case CONTINUE:
3658 case CONVERT:
3659 case CREATE:
3660 case CURRENT:
3661 case CURRVAL:
3662 case CURSOR:
3663 case DATA:
3664 case DATE:
3665 case DAY:
3666 case DECLARE:
3667 case DECIMAL:
3668 case _DEFAULT:
3669 case DELETE:
3670 case DESC:
3671 case DISABLE:
3672 case DISTINCT:
3673 case DO:
3674 case DROP:
3675 case EDITIONABLE:
3676 case ELEMENT:
3677 case ELSE:
3678 case ELSIF:
3679 case ENABLE:
3680 case ESCAPE:
3681 case EXCEPT:
3682 case EXCEPTION:
3683 case EXCEPTIONS:
3684 case EXCLUSIVE:
3685 case EXECUTE:
3686 case EXISTS:
3687 case EXIT:
3688 case EXTERNAL:
3689 case EXTENDS:
3690 case EXTRACT:
3691 case FALSE:
3692 case FETCH:
3693 case FINAL:
3694 case FLOAT:
3695 case FOR:
3696 case FORALL:
3697 case FORCE:
3698 case FROM:
3699 case FUNCTION:
3700 case GLOBAL:
3701 case GOTO:
3702 case GROUP:
3703 case HASH:
3704 case HAVING:
3705 case HEAP:
3706 case HOUR:
3707 case IF:
3708 case IMMEDIATE:
3709 case IN:
3710 case INDEX:
3711 case INDICES:
3712 case INDEXTYPE:
3713 case INDICATOR:
3714 case INSERT:
3715 case INSTANTIABLE:
3716 case INTEGER:
3717 case INTERFACE:
3718 case INTERSECT:
3719 case INTERVAL:
3720 case INTO:
3721 case INVALIDATE:
3722 case IS:
3723 case ISOLATION:
3724 case JAVA:
3725 case LEVEL:
3726 case LIKE:
3727 case LIMIT:
3728 case LIMITED:
3729 case LOCK:
3730 case LONG:
3731 case LOOP:
3732 case MAP:
3733 case MAX:
3734 case MEMBER:
3735 case MERGE:
3736 case MIN:
3737 case MINUS:
3738 case MINUTE:
3739 case MLSLABEL:
3740 case MODIFY:
3741 case MOD:
3742 case MODE:
3743 case MONTH:
3744 case NATURAL:
3745 case NATURALN:
3746 case NEW:
3747 case NEXTVAL:
3748 case NO:
3749 case NOCOPY:
3750 case NONEDITIONABLE:
3751 case NOT:
3752 case NOWAIT:
3753 case NULL:
3754 case NULLIF:
3755 case NUMBER:
3756 case BFILE_BASE:
3757 case BLOB_BASE:
3758 case CLOB_BASE:
3759 case DATE_BASE:
3760 case NUMBER_BASE:
3761 case OBJECT:
3762 case OCIROWID:
3763 case OF:
3764 case OID:
3765 case ON:
3766 case OPAQUE:
3767 case OPEN:
3768 case OPERATOR:
3769 case OPTION:
3770 case OR:
3771 case ORDER:
3772 case ORGANIZATION:
3773 case OTHERS:
3774 case OUT:
3775 case OVERRIDING:
3776 case PACKAGE:
3777 case PARTITION:
3778 case PCTFREE:
3779 case PLS_INTEGER:
3780 case POSITIVE:
3781 case POSITIVEN:
3782 case PRAGMA:
3783 case PRESERVE:
3784 case PRIOR:
3785 case PROMPT:
3786 case PRIVATE:
3787 case PROCEDURE:
3788 case PUBLIC:
3789 case RAISE:
3790 case RANGE:
3791 case RAW:
3792 case REAL:
3793 case RECORD:
3794 case REF:
3795 case RELEASE:
3796 case RELIES_ON:
3797 case RENAME:
3798 case RESULT:
3799 case RETURN:
3800 case RETURNING:
3801 case REVERSE:
3802 case ROLLBACK:
3803 case ROW:
3804 case ROWS:
3805 case ROWID:
3806 case ROWNUM:
3807 case ROWTYPE:
3808 case SAVE:
3809 case SAVEPOINT:
3810 case SECOND:
3811 case SELECT:
3812 case SELF:
3813 case SEPARATE:
3814 case SET:
3815 case SHARE:
3816 case SMALLINT:
3817 case SPACE:
3818 case SQL:
3819 case SQLCODE:
3820 case SQLERRM:
3821 case START:
3822 case STATIC:
3823 case STDDEV:
3824 case SUBTYPE:
3825 case SUBSTITUTABLE:
3826 case SUCCESSFUL:
3827 case SUM:
3828 case SYNONYM:
3829 case SYSDATE:
3830 case SYS_REFCURSOR:
3831 case TABLE:
3832 case TEMPORARY:
3833 case THEN:
3834 case TIME:
3835 case TIMESTAMP:
3836 case TIMEZONE_REGION:
3837 case TIMEZONE_ABBR:
3838 case TIMEZONE_MINUTE:
3839 case TIMEZONE_HOUR:
3840 case TO:
3841 case TRANSACTION:
3842 case TRIGGER:
3843 case TRUE:
3844 case TYPE:
3845 case UI:
3846 case UNDER:
3847 case USING:
3848 case WHILE:
3849 case YES:
3850 case SHOW:
3851 case A:
3852 case UPDATE:
3853 case VARCHAR:
3854 case VARCHAR2:
3855 case DOUBLE:
3856 case DEC:
3857 case PRECISION:
3858 case INT:
3859 case NUMERIC:
3860 case SIGNTYPE:
3861 case NCHAR:
3862 case NVARCHAR2:
3863 case STRING:
3864 case UROWID:
3865 case VARRAY:
3866 case VARYING:
3867 case BFILE:
3868 case BLOB:
3869 case CLOB:
3870 case NCLOB:
3871 case YEAR:
3872 case LOCAL:
3873 case WITH:
3874 case ZONE:
3875 case CHARACTER:
3876 case AFTER:
3877 case BEFORE:
3878 case OLD:
3879 case PARENT:
3880 case CC_IF:
3881 case ANALYZE:
3882 case ASSOCIATE:
3883 case AUDIT:
3884 case COMPOUND:
3885 case DATABASE:
3886 case CALL:
3887 case DDL:
3888 case DISASSOCIATE:
3889 case EACH:
3890 case FOLLOWS:
3891 case LOGOFF:
3892 case LOGON:
3893 case NESTED:
3894 case NOAUDIT:
3895 case SCHEMA:
3896 case SERVERERROR:
3897 case SHUTDOWN:
3898 case STARTUP:
3899 case STATEMENT:
3900 case STATISTICS:
3901 case SUSPEND:
3902 case TRUNCATE:
3903 case WRAPPED:
3904 case LIBRARY:
3905 case NAME:
3906 case STRUCT:
3907 case CONTEXT:
3908 case PARAMETERS:
3909 case LENGTH:
3910 case TDO:
3911 case MAXLEN:
3912 case CHARSETID:
3913 case CHARSETFORM:
3914 case ACCEPT:
3915 case ACCESSIBLE:
3916 case COPY:
3917 case DEFINE:
3918 case DISCONNECT:
3919 case HOST:
3920 case PRINT:
3921 case QUIT:
3922 case REMARK:
3923 case UNDEFINE:
3924 case VARIABLE:
3925 case WHENEVER:
3926 case ATTACH:
3927 case CAST:
3928 case TREAT:
3929 case TRIM:
3930 case LEFT:
3931 case RIGHT:
3932 case BOTH:
3933 case EMPTY:
3934 case MULTISET:
3935 case SUBMULTISET:
3936 case LEADING:
3937 case TRAILING:
3938 case CHAR_CS:
3939 case NCHAR_CS:
3940 case DBTIMEZONE:
3941 case SESSIONTIMEZONE:
3942 case AUTHENTICATED:
3943 case LINK:
3944 case SHARED:
3945 case DIRECTORY:
3946 case USER:
3947 case IDENTIFIER:
3948 case QUOTED_LITERAL:
3949 case SQLDATA_CLASS:
3950 case CUSTOMDATUM_CLASS:
3951 case ORADATA_CLASS:
3952 case JAVA_INTERFACE_CLASS:
3953 DeclarativeUnit();
3954 break;
3955 case CC_ERROR:
3956 jj_consume_token(CC_ERROR);
3957 Expression();
3958 jj_consume_token(CC_END);
3959 break;
3960 default:
3961 jj_la1[38] = jj_gen;
3962 jj_consume_token(-1);
3963 throw new ParseException();
3964 }
3965 }
3966 }
3967 label_11:
3968 while (true) {
3969 switch (jj_nt.kind) {
3970 case CC_ELSE:
3971 ;
3972 break;
3973 default:
3974 jj_la1[39] = jj_gen;
3975 break label_11;
3976 }
3977 jj_consume_token(CC_ELSE);
3978 label_12:
3979 while (true) {
3980 switch (jj_nt.kind) {
3981 case REPLACE:
3982 case DEFINER:
3983 case CURRENT_USER:
3984 case SERIALLY_REUSABLE:
3985 case RESTRICT_REFERENCES:
3986 case EXCEPTION_INIT:
3987 case AUTONOMOUS_TRANSACTION:
3988 case LANGUAGE:
3989 case INLINE:
3990 case ADD:
3991 case AGGREGATE:
3992 case ALL:
3993 case ALTER:
3994 case AND:
3995 case ANY:
3996 case ARRAY:
3997 case AS:
3998 case ASC:
3999 case AT:
4000 case ATTRIBUTE:
4001 case AUTHID:
4002 case AVG:
4003 case BETWEEN:
4004 case BINARY_INTEGER:
4005 case BODY:
4006 case BOOLEAN:
4007 case BULK:
4008 case BY:
4009 case BYTE:
4010 case CASCADE:
4011 case CASE:
4012 case CHAR:
4013 case CHAR_BASE:
4014 case CHECK:
4015 case CLOSE:
4016 case CLUSTER:
4017 case COALESCE:
4018 case COLLECT:
4019 case COLUMN:
4020 case COMMENT:
4021 case COMMIT:
4022 case COMPRESS:
4023 case CONNECT:
4024 case CONSTANT:
4025 case CONSTRUCTOR:
4026 case CONTINUE:
4027 case CONVERT:
4028 case CREATE:
4029 case CURRENT:
4030 case CURRVAL:
4031 case CURSOR:
4032 case DATA:
4033 case DATE:
4034 case DAY:
4035 case DECLARE:
4036 case DECIMAL:
4037 case _DEFAULT:
4038 case DELETE:
4039 case DESC:
4040 case DISABLE:
4041 case DISTINCT:
4042 case DO:
4043 case DROP:
4044 case EDITIONABLE:
4045 case ELEMENT:
4046 case ELSE:
4047 case ELSIF:
4048 case ENABLE:
4049 case ESCAPE:
4050 case EXCEPT:
4051 case EXCEPTION:
4052 case EXCEPTIONS:
4053 case EXCLUSIVE:
4054 case EXECUTE:
4055 case EXISTS:
4056 case EXIT:
4057 case EXTERNAL:
4058 case EXTENDS:
4059 case EXTRACT:
4060 case FALSE:
4061 case FETCH:
4062 case FINAL:
4063 case FLOAT:
4064 case FOR:
4065 case FORALL:
4066 case FORCE:
4067 case FROM:
4068 case FUNCTION:
4069 case GLOBAL:
4070 case GOTO:
4071 case GROUP:
4072 case HASH:
4073 case HAVING:
4074 case HEAP:
4075 case HOUR:
4076 case IF:
4077 case IMMEDIATE:
4078 case IN:
4079 case INDEX:
4080 case INDICES:
4081 case INDEXTYPE:
4082 case INDICATOR:
4083 case INSERT:
4084 case INSTANTIABLE:
4085 case INTEGER:
4086 case INTERFACE:
4087 case INTERSECT:
4088 case INTERVAL:
4089 case INTO:
4090 case INVALIDATE:
4091 case IS:
4092 case ISOLATION:
4093 case JAVA:
4094 case LEVEL:
4095 case LIKE:
4096 case LIMIT:
4097 case LIMITED:
4098 case LOCK:
4099 case LONG:
4100 case LOOP:
4101 case MAP:
4102 case MAX:
4103 case MEMBER:
4104 case MERGE:
4105 case MIN:
4106 case MINUS:
4107 case MINUTE:
4108 case MLSLABEL:
4109 case MODIFY:
4110 case MOD:
4111 case MODE:
4112 case MONTH:
4113 case NATURAL:
4114 case NATURALN:
4115 case NEW:
4116 case NEXTVAL:
4117 case NO:
4118 case NOCOPY:
4119 case NONEDITIONABLE:
4120 case NOT:
4121 case NOWAIT:
4122 case NULL:
4123 case NULLIF:
4124 case NUMBER:
4125 case BFILE_BASE:
4126 case BLOB_BASE:
4127 case CLOB_BASE:
4128 case DATE_BASE:
4129 case NUMBER_BASE:
4130 case OBJECT:
4131 case OCIROWID:
4132 case OF:
4133 case OID:
4134 case ON:
4135 case OPAQUE:
4136 case OPEN:
4137 case OPERATOR:
4138 case OPTION:
4139 case OR:
4140 case ORDER:
4141 case ORGANIZATION:
4142 case OTHERS:
4143 case OUT:
4144 case OVERRIDING:
4145 case PACKAGE:
4146 case PARTITION:
4147 case PCTFREE:
4148 case PLS_INTEGER:
4149 case POSITIVE:
4150 case POSITIVEN:
4151 case PRAGMA:
4152 case PRESERVE:
4153 case PRIOR:
4154 case PROMPT:
4155 case PRIVATE:
4156 case PROCEDURE:
4157 case PUBLIC:
4158 case RAISE:
4159 case RANGE:
4160 case RAW:
4161 case REAL:
4162 case RECORD:
4163 case REF:
4164 case RELEASE:
4165 case RELIES_ON:
4166 case RENAME:
4167 case RESULT:
4168 case RETURN:
4169 case RETURNING:
4170 case REVERSE:
4171 case ROLLBACK:
4172 case ROW:
4173 case ROWS:
4174 case ROWID:
4175 case ROWNUM:
4176 case ROWTYPE:
4177 case SAVE:
4178 case SAVEPOINT:
4179 case SECOND:
4180 case SELECT:
4181 case SELF:
4182 case SEPARATE:
4183 case SET:
4184 case SHARE:
4185 case SMALLINT:
4186 case SPACE:
4187 case SQL:
4188 case SQLCODE:
4189 case SQLERRM:
4190 case START:
4191 case STATIC:
4192 case STDDEV:
4193 case SUBTYPE:
4194 case SUBSTITUTABLE:
4195 case SUCCESSFUL:
4196 case SUM:
4197 case SYNONYM:
4198 case SYSDATE:
4199 case SYS_REFCURSOR:
4200 case TABLE:
4201 case TEMPORARY:
4202 case THEN:
4203 case TIME:
4204 case TIMESTAMP:
4205 case TIMEZONE_REGION:
4206 case TIMEZONE_ABBR:
4207 case TIMEZONE_MINUTE:
4208 case TIMEZONE_HOUR:
4209 case TO:
4210 case TRANSACTION:
4211 case TRIGGER:
4212 case TRUE:
4213 case TYPE:
4214 case UI:
4215 case UNDER:
4216 case USING:
4217 case WHILE:
4218 case YES:
4219 case SHOW:
4220 case A:
4221 case UPDATE:
4222 case VARCHAR:
4223 case VARCHAR2:
4224 case DOUBLE:
4225 case DEC:
4226 case PRECISION:
4227 case INT:
4228 case NUMERIC:
4229 case SIGNTYPE:
4230 case NCHAR:
4231 case NVARCHAR2:
4232 case STRING:
4233 case UROWID:
4234 case VARRAY:
4235 case VARYING:
4236 case BFILE:
4237 case BLOB:
4238 case CLOB:
4239 case NCLOB:
4240 case YEAR:
4241 case LOCAL:
4242 case WITH:
4243 case ZONE:
4244 case CHARACTER:
4245 case AFTER:
4246 case BEFORE:
4247 case OLD:
4248 case PARENT:
4249 case CC_IF:
4250 case CC_ERROR:
4251 case ANALYZE:
4252 case ASSOCIATE:
4253 case AUDIT:
4254 case COMPOUND:
4255 case DATABASE:
4256 case CALL:
4257 case DDL:
4258 case DISASSOCIATE:
4259 case EACH:
4260 case FOLLOWS:
4261 case LOGOFF:
4262 case LOGON:
4263 case NESTED:
4264 case NOAUDIT:
4265 case SCHEMA:
4266 case SERVERERROR:
4267 case SHUTDOWN:
4268 case STARTUP:
4269 case STATEMENT:
4270 case STATISTICS:
4271 case SUSPEND:
4272 case TRUNCATE:
4273 case WRAPPED:
4274 case LIBRARY:
4275 case NAME:
4276 case STRUCT:
4277 case CONTEXT:
4278 case PARAMETERS:
4279 case LENGTH:
4280 case TDO:
4281 case MAXLEN:
4282 case CHARSETID:
4283 case CHARSETFORM:
4284 case ACCEPT:
4285 case ACCESSIBLE:
4286 case COPY:
4287 case DEFINE:
4288 case DISCONNECT:
4289 case HOST:
4290 case PRINT:
4291 case QUIT:
4292 case REMARK:
4293 case UNDEFINE:
4294 case VARIABLE:
4295 case WHENEVER:
4296 case ATTACH:
4297 case CAST:
4298 case TREAT:
4299 case TRIM:
4300 case LEFT:
4301 case RIGHT:
4302 case BOTH:
4303 case EMPTY:
4304 case MULTISET:
4305 case SUBMULTISET:
4306 case LEADING:
4307 case TRAILING:
4308 case CHAR_CS:
4309 case NCHAR_CS:
4310 case DBTIMEZONE:
4311 case SESSIONTIMEZONE:
4312 case AUTHENTICATED:
4313 case LINK:
4314 case SHARED:
4315 case DIRECTORY:
4316 case USER:
4317 case IDENTIFIER:
4318 case QUOTED_LITERAL:
4319 case SQLDATA_CLASS:
4320 case CUSTOMDATUM_CLASS:
4321 case ORADATA_CLASS:
4322 case JAVA_INTERFACE_CLASS:
4323 ;
4324 break;
4325 default:
4326 jj_la1[40] = jj_gen;
4327 break label_12;
4328 }
4329 switch (jj_nt.kind) {
4330 case REPLACE:
4331 case DEFINER:
4332 case CURRENT_USER:
4333 case SERIALLY_REUSABLE:
4334 case RESTRICT_REFERENCES:
4335 case EXCEPTION_INIT:
4336 case AUTONOMOUS_TRANSACTION:
4337 case LANGUAGE:
4338 case INLINE:
4339 case ADD:
4340 case AGGREGATE:
4341 case ALL:
4342 case ALTER:
4343 case AND:
4344 case ANY:
4345 case ARRAY:
4346 case AS:
4347 case ASC:
4348 case AT:
4349 case ATTRIBUTE:
4350 case AUTHID:
4351 case AVG:
4352 case BETWEEN:
4353 case BINARY_INTEGER:
4354 case BODY:
4355 case BOOLEAN:
4356 case BULK:
4357 case BY:
4358 case BYTE:
4359 case CASCADE:
4360 case CASE:
4361 case CHAR:
4362 case CHAR_BASE:
4363 case CHECK:
4364 case CLOSE:
4365 case CLUSTER:
4366 case COALESCE:
4367 case COLLECT:
4368 case COLUMN:
4369 case COMMENT:
4370 case COMMIT:
4371 case COMPRESS:
4372 case CONNECT:
4373 case CONSTANT:
4374 case CONSTRUCTOR:
4375 case CONTINUE:
4376 case CONVERT:
4377 case CREATE:
4378 case CURRENT:
4379 case CURRVAL:
4380 case CURSOR:
4381 case DATA:
4382 case DATE:
4383 case DAY:
4384 case DECLARE:
4385 case DECIMAL:
4386 case _DEFAULT:
4387 case DELETE:
4388 case DESC:
4389 case DISABLE:
4390 case DISTINCT:
4391 case DO:
4392 case DROP:
4393 case EDITIONABLE:
4394 case ELEMENT:
4395 case ELSE:
4396 case ELSIF:
4397 case ENABLE:
4398 case ESCAPE:
4399 case EXCEPT:
4400 case EXCEPTION:
4401 case EXCEPTIONS:
4402 case EXCLUSIVE:
4403 case EXECUTE:
4404 case EXISTS:
4405 case EXIT:
4406 case EXTERNAL:
4407 case EXTENDS:
4408 case EXTRACT:
4409 case FALSE:
4410 case FETCH:
4411 case FINAL:
4412 case FLOAT:
4413 case FOR:
4414 case FORALL:
4415 case FORCE:
4416 case FROM:
4417 case FUNCTION:
4418 case GLOBAL:
4419 case GOTO:
4420 case GROUP:
4421 case HASH:
4422 case HAVING:
4423 case HEAP:
4424 case HOUR:
4425 case IF:
4426 case IMMEDIATE:
4427 case IN:
4428 case INDEX:
4429 case INDICES:
4430 case INDEXTYPE:
4431 case INDICATOR:
4432 case INSERT:
4433 case INSTANTIABLE:
4434 case INTEGER:
4435 case INTERFACE:
4436 case INTERSECT:
4437 case INTERVAL:
4438 case INTO:
4439 case INVALIDATE:
4440 case IS:
4441 case ISOLATION:
4442 case JAVA:
4443 case LEVEL:
4444 case LIKE:
4445 case LIMIT:
4446 case LIMITED:
4447 case LOCK:
4448 case LONG:
4449 case LOOP:
4450 case MAP:
4451 case MAX:
4452 case MEMBER:
4453 case MERGE:
4454 case MIN:
4455 case MINUS:
4456 case MINUTE:
4457 case MLSLABEL:
4458 case MODIFY:
4459 case MOD:
4460 case MODE:
4461 case MONTH:
4462 case NATURAL:
4463 case NATURALN:
4464 case NEW:
4465 case NEXTVAL:
4466 case NO:
4467 case NOCOPY:
4468 case NONEDITIONABLE:
4469 case NOT:
4470 case NOWAIT:
4471 case NULL:
4472 case NULLIF:
4473 case NUMBER:
4474 case BFILE_BASE:
4475 case BLOB_BASE:
4476 case CLOB_BASE:
4477 case DATE_BASE:
4478 case NUMBER_BASE:
4479 case OBJECT:
4480 case OCIROWID:
4481 case OF:
4482 case OID:
4483 case ON:
4484 case OPAQUE:
4485 case OPEN:
4486 case OPERATOR:
4487 case OPTION:
4488 case OR:
4489 case ORDER:
4490 case ORGANIZATION:
4491 case OTHERS:
4492 case OUT:
4493 case OVERRIDING:
4494 case PACKAGE:
4495 case PARTITION:
4496 case PCTFREE:
4497 case PLS_INTEGER:
4498 case POSITIVE:
4499 case POSITIVEN:
4500 case PRAGMA:
4501 case PRESERVE:
4502 case PRIOR:
4503 case PROMPT:
4504 case PRIVATE:
4505 case PROCEDURE:
4506 case PUBLIC:
4507 case RAISE:
4508 case RANGE:
4509 case RAW:
4510 case REAL:
4511 case RECORD:
4512 case REF:
4513 case RELEASE:
4514 case RELIES_ON:
4515 case RENAME:
4516 case RESULT:
4517 case RETURN:
4518 case RETURNING:
4519 case REVERSE:
4520 case ROLLBACK:
4521 case ROW:
4522 case ROWS:
4523 case ROWID:
4524 case ROWNUM:
4525 case ROWTYPE:
4526 case SAVE:
4527 case SAVEPOINT:
4528 case SECOND:
4529 case SELECT:
4530 case SELF:
4531 case SEPARATE:
4532 case SET:
4533 case SHARE:
4534 case SMALLINT:
4535 case SPACE:
4536 case SQL:
4537 case SQLCODE:
4538 case SQLERRM:
4539 case START:
4540 case STATIC:
4541 case STDDEV:
4542 case SUBTYPE:
4543 case SUBSTITUTABLE:
4544 case SUCCESSFUL:
4545 case SUM:
4546 case SYNONYM:
4547 case SYSDATE:
4548 case SYS_REFCURSOR:
4549 case TABLE:
4550 case TEMPORARY:
4551 case THEN:
4552 case TIME:
4553 case TIMESTAMP:
4554 case TIMEZONE_REGION:
4555 case TIMEZONE_ABBR:
4556 case TIMEZONE_MINUTE:
4557 case TIMEZONE_HOUR:
4558 case TO:
4559 case TRANSACTION:
4560 case TRIGGER:
4561 case TRUE:
4562 case TYPE:
4563 case UI:
4564 case UNDER:
4565 case USING:
4566 case WHILE:
4567 case YES:
4568 case SHOW:
4569 case A:
4570 case UPDATE:
4571 case VARCHAR:
4572 case VARCHAR2:
4573 case DOUBLE:
4574 case DEC:
4575 case PRECISION:
4576 case INT:
4577 case NUMERIC:
4578 case SIGNTYPE:
4579 case NCHAR:
4580 case NVARCHAR2:
4581 case STRING:
4582 case UROWID:
4583 case VARRAY:
4584 case VARYING:
4585 case BFILE:
4586 case BLOB:
4587 case CLOB:
4588 case NCLOB:
4589 case YEAR:
4590 case LOCAL:
4591 case WITH:
4592 case ZONE:
4593 case CHARACTER:
4594 case AFTER:
4595 case BEFORE:
4596 case OLD:
4597 case PARENT:
4598 case CC_IF:
4599 case ANALYZE:
4600 case ASSOCIATE:
4601 case AUDIT:
4602 case COMPOUND:
4603 case DATABASE:
4604 case CALL:
4605 case DDL:
4606 case DISASSOCIATE:
4607 case EACH:
4608 case FOLLOWS:
4609 case LOGOFF:
4610 case LOGON:
4611 case NESTED:
4612 case NOAUDIT:
4613 case SCHEMA:
4614 case SERVERERROR:
4615 case SHUTDOWN:
4616 case STARTUP:
4617 case STATEMENT:
4618 case STATISTICS:
4619 case SUSPEND:
4620 case TRUNCATE:
4621 case WRAPPED:
4622 case LIBRARY:
4623 case NAME:
4624 case STRUCT:
4625 case CONTEXT:
4626 case PARAMETERS:
4627 case LENGTH:
4628 case TDO:
4629 case MAXLEN:
4630 case CHARSETID:
4631 case CHARSETFORM:
4632 case ACCEPT:
4633 case ACCESSIBLE:
4634 case COPY:
4635 case DEFINE:
4636 case DISCONNECT:
4637 case HOST:
4638 case PRINT:
4639 case QUIT:
4640 case REMARK:
4641 case UNDEFINE:
4642 case VARIABLE:
4643 case WHENEVER:
4644 case ATTACH:
4645 case CAST:
4646 case TREAT:
4647 case TRIM:
4648 case LEFT:
4649 case RIGHT:
4650 case BOTH:
4651 case EMPTY:
4652 case MULTISET:
4653 case SUBMULTISET:
4654 case LEADING:
4655 case TRAILING:
4656 case CHAR_CS:
4657 case NCHAR_CS:
4658 case DBTIMEZONE:
4659 case SESSIONTIMEZONE:
4660 case AUTHENTICATED:
4661 case LINK:
4662 case SHARED:
4663 case DIRECTORY:
4664 case USER:
4665 case IDENTIFIER:
4666 case QUOTED_LITERAL:
4667 case SQLDATA_CLASS:
4668 case CUSTOMDATUM_CLASS:
4669 case ORADATA_CLASS:
4670 case JAVA_INTERFACE_CLASS:
4671 DeclarativeUnit();
4672 break;
4673 case CC_ERROR:
4674 jj_consume_token(CC_ERROR);
4675 Expression();
4676 jj_consume_token(CC_END);
4677 break;
4678 default:
4679 jj_la1[41] = jj_gen;
4680 jj_consume_token(-1);
4681 throw new ParseException();
4682 }
4683 }
4684 }
4685 jj_consume_token(CC_END);
4686 jjtree.closeNodeScope(jjtn000, true);
4687 jjtc000 = false;
4688 {if (true) return jjtn000 ;}
4689 } catch (Throwable jjte000) {
4690 if (jjtc000) {
4691 jjtree.clearNodeScope(jjtn000);
4692 jjtc000 = false;
4693 } else {
4694 jjtree.popNode();
4695 }
4696 if (jjte000 instanceof RuntimeException) {
4697 {if (true) throw (RuntimeException)jjte000;}
4698 }
4699 if (jjte000 instanceof ParseException) {
4700 {if (true) throw (ParseException)jjte000;}
4701 }
4702 {if (true) throw (Error)jjte000;}
4703 } finally {
4704 if (jjtc000) {
4705 jjtree.closeNodeScope(jjtn000, true);
4706 }
4707 }
4708 throw new Error("Missing return statement in function");
4709 }
4710
4711
4712
4713
4714
4715
4716
4717 final public ASTProgramUnit ProgramUnit() throws ParseException {
4718
4719 ASTProgramUnit jjtn000 = new ASTProgramUnit(this, JJTPROGRAMUNIT);
4720 boolean jjtc000 = true;
4721 jjtree.openNodeScope(jjtn000);
4722 try {
4723 switch (jj_nt.kind) {
4724 case CREATE:
4725 jj_consume_token(CREATE);
4726 switch (jj_nt.kind) {
4727 case OR:
4728 jj_consume_token(OR);
4729 jj_consume_token(REPLACE);
4730 break;
4731 default:
4732 jj_la1[42] = jj_gen;
4733 ;
4734 }
4735 switch (jj_nt.kind) {
4736 case EDITIONABLE:
4737 case NONEDITIONABLE:
4738 switch (jj_nt.kind) {
4739 case EDITIONABLE:
4740 jj_consume_token(EDITIONABLE);
4741 break;
4742 case NONEDITIONABLE:
4743 jj_consume_token(NONEDITIONABLE);
4744 break;
4745 default:
4746 jj_la1[43] = jj_gen;
4747 jj_consume_token(-1);
4748 throw new ParseException();
4749 }
4750 break;
4751 default:
4752 jj_la1[44] = jj_gen;
4753 ;
4754 }
4755 break;
4756 default:
4757 jj_la1[45] = jj_gen;
4758 ;
4759 }
4760 MethodDeclarator();
4761 switch (jj_nt.kind) {
4762 case WRAPPED:
4763 WrappedObject();
4764 break;
4765 case 4:
4766 case AGGREGATE:
4767 case AS:
4768 case AUTHID:
4769 case DETERMINISTIC:
4770 case IS:
4771 case PARALLEL_ENABLE:
4772 case PIPELINED:
4773 case RESULT_CACHE:
4774 case ACCESSIBLE:
4775 label_13:
4776 while (true) {
4777 switch (jj_nt.kind) {
4778 case AUTHID:
4779 case DETERMINISTIC:
4780 case PARALLEL_ENABLE:
4781 case PIPELINED:
4782 case RESULT_CACHE:
4783 case ACCESSIBLE:
4784 ;
4785 break;
4786 default:
4787 jj_la1[46] = jj_gen;
4788 break label_13;
4789 }
4790 switch (jj_nt.kind) {
4791 case AUTHID:
4792 jj_consume_token(AUTHID);
4793 switch (jj_nt.kind) {
4794 case CURRENT_USER:
4795 jj_consume_token(CURRENT_USER);
4796 break;
4797 case DEFINER:
4798 jj_consume_token(DEFINER);
4799 break;
4800 default:
4801 jj_la1[47] = jj_gen;
4802 jj_consume_token(-1);
4803 throw new ParseException();
4804 }
4805 break;
4806 case DETERMINISTIC:
4807 jj_consume_token(DETERMINISTIC);
4808 break;
4809 case ACCESSIBLE:
4810 AccessibleByClause();
4811 break;
4812 case PARALLEL_ENABLE:
4813 jj_consume_token(PARALLEL_ENABLE);
4814 switch (jj_nt.kind) {
4815 case 5:
4816 ParallelClause();
4817 break;
4818 default:
4819 jj_la1[48] = jj_gen;
4820 ;
4821 }
4822 switch (jj_nt.kind) {
4823 case USING:
4824 jj_consume_token(USING);
4825 ID();
4826 switch (jj_nt.kind) {
4827 case 3:
4828 jj_consume_token(3);
4829 ID();
4830 break;
4831 default:
4832 jj_la1[49] = jj_gen;
4833 ;
4834 }
4835 break;
4836 default:
4837 jj_la1[50] = jj_gen;
4838 ;
4839 }
4840 break;
4841 case PIPELINED:
4842 jj_consume_token(PIPELINED);
4843 switch (jj_nt.kind) {
4844 case CLUSTER:
4845 case ORDER:
4846 case USING:
4847 switch (jj_nt.kind) {
4848 case USING:
4849 jj_consume_token(USING);
4850 ID();
4851 switch (jj_nt.kind) {
4852 case 3:
4853 jj_consume_token(3);
4854 ID();
4855 break;
4856 default:
4857 jj_la1[51] = jj_gen;
4858 ;
4859 }
4860 break;
4861 case CLUSTER:
4862 case ORDER:
4863 switch (jj_nt.kind) {
4864 case ORDER:
4865 jj_consume_token(ORDER);
4866 break;
4867 case CLUSTER:
4868 jj_consume_token(CLUSTER);
4869 break;
4870 default:
4871 jj_la1[52] = jj_gen;
4872 jj_consume_token(-1);
4873 throw new ParseException();
4874 }
4875 switch (jj_nt.kind) {
4876 case REPLACE:
4877 case DEFINER:
4878 case CURRENT_USER:
4879 case SERIALLY_REUSABLE:
4880 case RESTRICT_REFERENCES:
4881 case EXCEPTION_INIT:
4882 case AUTONOMOUS_TRANSACTION:
4883 case LANGUAGE:
4884 case INLINE:
4885 case ADD:
4886 case AGGREGATE:
4887 case ALL:
4888 case ALTER:
4889 case AND:
4890 case ANY:
4891 case ARRAY:
4892 case AS:
4893 case ASC:
4894 case AT:
4895 case ATTRIBUTE:
4896 case AUTHID:
4897 case AVG:
4898 case BETWEEN:
4899 case BINARY_INTEGER:
4900 case BODY:
4901 case BOOLEAN:
4902 case BULK:
4903 case BY:
4904 case BYTE:
4905 case CASCADE:
4906 case CASE:
4907 case CHAR:
4908 case CHAR_BASE:
4909 case CHECK:
4910 case CLOSE:
4911 case CLUSTER:
4912 case COALESCE:
4913 case COLLECT:
4914 case COLUMN:
4915 case COMMENT:
4916 case COMMIT:
4917 case COMPRESS:
4918 case CONNECT:
4919 case CONSTANT:
4920 case CONSTRUCTOR:
4921 case CONTINUE:
4922 case CONVERT:
4923 case CREATE:
4924 case CURRENT:
4925 case CURRVAL:
4926 case CURSOR:
4927 case DATA:
4928 case DATE:
4929 case DAY:
4930 case DECLARE:
4931 case DECIMAL:
4932 case _DEFAULT:
4933 case DELETE:
4934 case DESC:
4935 case DISABLE:
4936 case DISTINCT:
4937 case DO:
4938 case DROP:
4939 case EDITIONABLE:
4940 case ELEMENT:
4941 case ELSE:
4942 case ELSIF:
4943 case ENABLE:
4944 case ESCAPE:
4945 case EXCEPT:
4946 case EXCEPTION:
4947 case EXCEPTIONS:
4948 case EXCLUSIVE:
4949 case EXECUTE:
4950 case EXISTS:
4951 case EXIT:
4952 case EXTERNAL:
4953 case EXTENDS:
4954 case EXTRACT:
4955 case FALSE:
4956 case FETCH:
4957 case FINAL:
4958 case FLOAT:
4959 case FOR:
4960 case FORALL:
4961 case FORCE:
4962 case FROM:
4963 case FUNCTION:
4964 case GLOBAL:
4965 case GOTO:
4966 case GROUP:
4967 case HASH:
4968 case HAVING:
4969 case HEAP:
4970 case HOUR:
4971 case IF:
4972 case IMMEDIATE:
4973 case IN:
4974 case INDEX:
4975 case INDICES:
4976 case INDEXTYPE:
4977 case INDICATOR:
4978 case INSERT:
4979 case INSTANTIABLE:
4980 case INTEGER:
4981 case INTERFACE:
4982 case INTERSECT:
4983 case INTERVAL:
4984 case INTO:
4985 case INVALIDATE:
4986 case IS:
4987 case ISOLATION:
4988 case JAVA:
4989 case LEVEL:
4990 case LIKE:
4991 case LIMIT:
4992 case LIMITED:
4993 case LOCK:
4994 case LONG:
4995 case LOOP:
4996 case MAP:
4997 case MAX:
4998 case MEMBER:
4999 case MERGE:
5000 case MIN:
5001 case MINUS:
5002 case MINUTE:
5003 case MLSLABEL:
5004 case MODIFY:
5005 case MOD:
5006 case MODE:
5007 case MONTH:
5008 case NATURAL:
5009 case NATURALN:
5010 case NEW:
5011 case NEXTVAL:
5012 case NO:
5013 case NOCOPY:
5014 case NONEDITIONABLE:
5015 case NOT:
5016 case NOWAIT:
5017 case NULL:
5018 case NULLIF:
5019 case NUMBER:
5020 case BFILE_BASE:
5021 case BLOB_BASE:
5022 case CLOB_BASE:
5023 case DATE_BASE:
5024 case NUMBER_BASE:
5025 case OBJECT:
5026 case OCIROWID:
5027 case OF:
5028 case OID:
5029 case ON:
5030 case OPAQUE:
5031 case OPEN:
5032 case OPERATOR:
5033 case OPTION:
5034 case OR:
5035 case ORDER:
5036 case ORGANIZATION:
5037 case OTHERS:
5038 case OUT:
5039 case OVERRIDING:
5040 case PACKAGE:
5041 case PARTITION:
5042 case PCTFREE:
5043 case PLS_INTEGER:
5044 case POSITIVE:
5045 case POSITIVEN:
5046 case PRESERVE:
5047 case PRIOR:
5048 case PROMPT:
5049 case PRIVATE:
5050 case PROCEDURE:
5051 case PUBLIC:
5052 case RAISE:
5053 case RANGE:
5054 case RAW:
5055 case REAL:
5056 case RECORD:
5057 case REF:
5058 case RELEASE:
5059 case RELIES_ON:
5060 case RENAME:
5061 case RESULT:
5062 case RETURN:
5063 case RETURNING:
5064 case REVERSE:
5065 case ROLLBACK:
5066 case ROW:
5067 case ROWS:
5068 case ROWID:
5069 case ROWNUM:
5070 case ROWTYPE:
5071 case SAVE:
5072 case SAVEPOINT:
5073 case SECOND:
5074 case SELECT:
5075 case SELF:
5076 case SEPARATE:
5077 case SET:
5078 case SHARE:
5079 case SMALLINT:
5080 case SPACE:
5081 case SQL:
5082 case SQLCODE:
5083 case SQLERRM:
5084 case START:
5085 case STATIC:
5086 case STDDEV:
5087 case SUBTYPE:
5088 case SUBSTITUTABLE:
5089 case SUCCESSFUL:
5090 case SUM:
5091 case SYNONYM:
5092 case SYSDATE:
5093 case SYS_REFCURSOR:
5094 case TABLE:
5095 case TEMPORARY:
5096 case THEN:
5097 case TIME:
5098 case TIMESTAMP:
5099 case TIMEZONE_REGION:
5100 case TIMEZONE_ABBR:
5101 case TIMEZONE_MINUTE:
5102 case TIMEZONE_HOUR:
5103 case TO:
5104 case TRANSACTION:
5105 case TRIGGER:
5106 case TRUE:
5107 case TYPE:
5108 case UI:
5109 case UNDER:
5110 case USING:
5111 case WHILE:
5112 case YES:
5113 case SHOW:
5114 case A:
5115 case UPDATE:
5116 case VARCHAR:
5117 case VARCHAR2:
5118 case DOUBLE:
5119 case DEC:
5120 case PRECISION:
5121 case INT:
5122 case NUMERIC:
5123 case SIGNTYPE:
5124 case NCHAR:
5125 case NVARCHAR2:
5126 case STRING:
5127 case UROWID:
5128 case VARRAY:
5129 case VARYING:
5130 case BFILE:
5131 case BLOB:
5132 case CLOB:
5133 case NCLOB:
5134 case YEAR:
5135 case LOCAL:
5136 case WITH:
5137 case ZONE:
5138 case CHARACTER:
5139 case AFTER:
5140 case BEFORE:
5141 case OLD:
5142 case PARENT:
5143 case ANALYZE:
5144 case ASSOCIATE:
5145 case AUDIT:
5146 case COMPOUND:
5147 case DATABASE:
5148 case CALL:
5149 case DDL:
5150 case DISASSOCIATE:
5151 case EACH:
5152 case FOLLOWS:
5153 case LOGOFF:
5154 case LOGON:
5155 case NESTED:
5156 case NOAUDIT:
5157 case SCHEMA:
5158 case SERVERERROR:
5159 case SHUTDOWN:
5160 case STARTUP:
5161 case STATEMENT:
5162 case STATISTICS:
5163 case SUSPEND:
5164 case TRUNCATE:
5165 case WRAPPED:
5166 case LIBRARY:
5167 case NAME:
5168 case STRUCT:
5169 case CONTEXT:
5170 case PARAMETERS:
5171 case LENGTH:
5172 case TDO:
5173 case MAXLEN:
5174 case CHARSETID:
5175 case CHARSETFORM:
5176 case ACCEPT:
5177 case ACCESSIBLE:
5178 case COPY:
5179 case DEFINE:
5180 case DISCONNECT:
5181 case HOST:
5182 case PRINT:
5183 case QUIT:
5184 case REMARK:
5185 case UNDEFINE:
5186 case VARIABLE:
5187 case WHENEVER:
5188 case ATTACH:
5189 case CAST:
5190 case TREAT:
5191 case TRIM:
5192 case LEFT:
5193 case RIGHT:
5194 case BOTH:
5195 case EMPTY:
5196 case MULTISET:
5197 case SUBMULTISET:
5198 case LEADING:
5199 case TRAILING:
5200 case CHAR_CS:
5201 case NCHAR_CS:
5202 case DBTIMEZONE:
5203 case SESSIONTIMEZONE:
5204 case AUTHENTICATED:
5205 case LINK:
5206 case SHARED:
5207 case DIRECTORY:
5208 case USER:
5209 case IDENTIFIER:
5210 case QUOTED_LITERAL:
5211 case SQLDATA_CLASS:
5212 case CUSTOMDATUM_CLASS:
5213 case ORADATA_CLASS:
5214 case JAVA_INTERFACE_CLASS:
5215 ID();
5216 break;
5217 default:
5218 jj_la1[53] = jj_gen;
5219 ;
5220 }
5221 jj_consume_token(BY);
5222 jj_consume_token(5);
5223 ID();
5224 label_14:
5225 while (true) {
5226 switch (jj_nt.kind) {
5227 case 6:
5228 ;
5229 break;
5230 default:
5231 jj_la1[54] = jj_gen;
5232 break label_14;
5233 }
5234 jj_consume_token(6);
5235 ID();
5236 }
5237 jj_consume_token(7);
5238 break;
5239 default:
5240 jj_la1[55] = jj_gen;
5241 jj_consume_token(-1);
5242 throw new ParseException();
5243 }
5244 break;
5245 default:
5246 jj_la1[56] = jj_gen;
5247 ;
5248 }
5249 break;
5250 case RESULT_CACHE:
5251 jj_consume_token(RESULT_CACHE);
5252 switch (jj_nt.kind) {
5253 case RELIES_ON:
5254 jj_consume_token(RELIES_ON);
5255 jj_consume_token(5);
5256 ID();
5257 switch (jj_nt.kind) {
5258 case 3:
5259 jj_consume_token(3);
5260 ID();
5261 break;
5262 default:
5263 jj_la1[57] = jj_gen;
5264 ;
5265 }
5266 label_15:
5267 while (true) {
5268 switch (jj_nt.kind) {
5269 case 6:
5270 ;
5271 break;
5272 default:
5273 jj_la1[58] = jj_gen;
5274 break label_15;
5275 }
5276 jj_consume_token(6);
5277 ID();
5278 switch (jj_nt.kind) {
5279 case 3:
5280 jj_consume_token(3);
5281 ID();
5282 break;
5283 default:
5284 jj_la1[59] = jj_gen;
5285 ;
5286 }
5287 }
5288 jj_consume_token(7);
5289 break;
5290 default:
5291 jj_la1[60] = jj_gen;
5292 ;
5293 }
5294 break;
5295 default:
5296 jj_la1[61] = jj_gen;
5297 jj_consume_token(-1);
5298 throw new ParseException();
5299 }
5300 }
5301 switch (jj_nt.kind) {
5302 case AGGREGATE:
5303 jj_consume_token(AGGREGATE);
5304 jj_consume_token(USING);
5305 ID();
5306 break;
5307 default:
5308 jj_la1[62] = jj_gen;
5309 ;
5310 }
5311 switch (jj_nt.kind) {
5312 case AS:
5313 case IS:
5314 switch (jj_nt.kind) {
5315 case IS:
5316 jj_consume_token(IS);
5317 break;
5318 case AS:
5319 jj_consume_token(AS);
5320 break;
5321 default:
5322 jj_la1[63] = jj_gen;
5323 jj_consume_token(-1);
5324 throw new ParseException();
5325 }
5326 if (jj_2_21(2)) {
5327 CallSpecTail();
5328 } else {
5329 switch (jj_nt.kind) {
5330 case REPLACE:
5331 case DEFINER:
5332 case CURRENT_USER:
5333 case SERIALLY_REUSABLE:
5334 case RESTRICT_REFERENCES:
5335 case EXCEPTION_INIT:
5336 case AUTONOMOUS_TRANSACTION:
5337 case LANGUAGE:
5338 case INLINE:
5339 case ADD:
5340 case AGGREGATE:
5341 case ALL:
5342 case ALTER:
5343 case AND:
5344 case ANY:
5345 case ARRAY:
5346 case AS:
5347 case ASC:
5348 case AT:
5349 case ATTRIBUTE:
5350 case AUTHID:
5351 case AVG:
5352 case BEGIN:
5353 case BETWEEN:
5354 case BINARY_INTEGER:
5355 case BODY:
5356 case BOOLEAN:
5357 case BULK:
5358 case BY:
5359 case BYTE:
5360 case CASCADE:
5361 case CASE:
5362 case CHAR:
5363 case CHAR_BASE:
5364 case CHECK:
5365 case CLOSE:
5366 case CLUSTER:
5367 case COALESCE:
5368 case COLLECT:
5369 case COLUMN:
5370 case COMMENT:
5371 case COMMIT:
5372 case COMPRESS:
5373 case CONNECT:
5374 case CONSTANT:
5375 case CONSTRUCTOR:
5376 case CONTINUE:
5377 case CONVERT:
5378 case CREATE:
5379 case CURRENT:
5380 case CURRVAL:
5381 case CURSOR:
5382 case DATA:
5383 case DATE:
5384 case DAY:
5385 case DECLARE:
5386 case DECIMAL:
5387 case _DEFAULT:
5388 case DELETE:
5389 case DESC:
5390 case DISABLE:
5391 case DISTINCT:
5392 case DO:
5393 case DROP:
5394 case EDITIONABLE:
5395 case ELEMENT:
5396 case ELSE:
5397 case ELSIF:
5398 case ENABLE:
5399 case ESCAPE:
5400 case EXCEPT:
5401 case EXCEPTION:
5402 case EXCEPTIONS:
5403 case EXCLUSIVE:
5404 case EXECUTE:
5405 case EXISTS:
5406 case EXIT:
5407 case EXTERNAL:
5408 case EXTENDS:
5409 case EXTRACT:
5410 case FALSE:
5411 case FETCH:
5412 case FINAL:
5413 case FLOAT:
5414 case FOR:
5415 case FORALL:
5416 case FORCE:
5417 case FROM:
5418 case FUNCTION:
5419 case GLOBAL:
5420 case GOTO:
5421 case GROUP:
5422 case HASH:
5423 case HAVING:
5424 case HEAP:
5425 case HOUR:
5426 case IF:
5427 case IMMEDIATE:
5428 case IN:
5429 case INDEX:
5430 case INDICES:
5431 case INDEXTYPE:
5432 case INDICATOR:
5433 case INSERT:
5434 case INSTANTIABLE:
5435 case INTEGER:
5436 case INTERFACE:
5437 case INTERSECT:
5438 case INTERVAL:
5439 case INTO:
5440 case INVALIDATE:
5441 case IS:
5442 case ISOLATION:
5443 case JAVA:
5444 case LEVEL:
5445 case LIKE:
5446 case LIMIT:
5447 case LIMITED:
5448 case LOCK:
5449 case LONG:
5450 case LOOP:
5451 case MAP:
5452 case MAX:
5453 case MEMBER:
5454 case MERGE:
5455 case MIN:
5456 case MINUS:
5457 case MINUTE:
5458 case MLSLABEL:
5459 case MODIFY:
5460 case MOD:
5461 case MODE:
5462 case MONTH:
5463 case NATURAL:
5464 case NATURALN:
5465 case NEW:
5466 case NEXTVAL:
5467 case NO:
5468 case NOCOPY:
5469 case NONEDITIONABLE:
5470 case NOT:
5471 case NOWAIT:
5472 case NULL:
5473 case NULLIF:
5474 case NUMBER:
5475 case BFILE_BASE:
5476 case BLOB_BASE:
5477 case CLOB_BASE:
5478 case DATE_BASE:
5479 case NUMBER_BASE:
5480 case OBJECT:
5481 case OCIROWID:
5482 case OF:
5483 case OID:
5484 case ON:
5485 case OPAQUE:
5486 case OPEN:
5487 case OPERATOR:
5488 case OPTION:
5489 case OR:
5490 case ORDER:
5491 case ORGANIZATION:
5492 case OTHERS:
5493 case OUT:
5494 case OVERRIDING:
5495 case PACKAGE:
5496 case PARTITION:
5497 case PCTFREE:
5498 case PLS_INTEGER:
5499 case POSITIVE:
5500 case POSITIVEN:
5501 case PRAGMA:
5502 case PRESERVE:
5503 case PRIOR:
5504 case PROMPT:
5505 case PRIVATE:
5506 case PROCEDURE:
5507 case PUBLIC:
5508 case RAISE:
5509 case RANGE:
5510 case RAW:
5511 case REAL:
5512 case RECORD:
5513 case REF:
5514 case RELEASE:
5515 case RELIES_ON:
5516 case RENAME:
5517 case RESULT:
5518 case RETURN:
5519 case RETURNING:
5520 case REVERSE:
5521 case ROLLBACK:
5522 case ROW:
5523 case ROWS:
5524 case ROWID:
5525 case ROWNUM:
5526 case ROWTYPE:
5527 case SAVE:
5528 case SAVEPOINT:
5529 case SECOND:
5530 case SELECT:
5531 case SELF:
5532 case SEPARATE:
5533 case SET:
5534 case SHARE:
5535 case SMALLINT:
5536 case SPACE:
5537 case SQL:
5538 case SQLCODE:
5539 case SQLERRM:
5540 case START:
5541 case STATIC:
5542 case STDDEV:
5543 case SUBTYPE:
5544 case SUBSTITUTABLE:
5545 case SUCCESSFUL:
5546 case SUM:
5547 case SYNONYM:
5548 case SYSDATE:
5549 case SYS_REFCURSOR:
5550 case TABLE:
5551 case TEMPORARY:
5552 case THEN:
5553 case TIME:
5554 case TIMESTAMP:
5555 case TIMEZONE_REGION:
5556 case TIMEZONE_ABBR:
5557 case TIMEZONE_MINUTE:
5558 case TIMEZONE_HOUR:
5559 case TO:
5560 case TRANSACTION:
5561 case TRIGGER:
5562 case TRUE:
5563 case TYPE:
5564 case UI:
5565 case UNDER:
5566 case USING:
5567 case WHILE:
5568 case YES:
5569 case SHOW:
5570 case A:
5571 case UPDATE:
5572 case VARCHAR:
5573 case VARCHAR2:
5574 case DOUBLE:
5575 case DEC:
5576 case PRECISION:
5577 case INT:
5578 case NUMERIC:
5579 case SIGNTYPE:
5580 case NCHAR:
5581 case NVARCHAR2:
5582 case STRING:
5583 case UROWID:
5584 case VARRAY:
5585 case VARYING:
5586 case BFILE:
5587 case BLOB:
5588 case CLOB:
5589 case NCLOB:
5590 case YEAR:
5591 case LOCAL:
5592 case WITH:
5593 case ZONE:
5594 case CHARACTER:
5595 case AFTER:
5596 case BEFORE:
5597 case OLD:
5598 case PARENT:
5599 case CC_IF:
5600 case ANALYZE:
5601 case ASSOCIATE:
5602 case AUDIT:
5603 case COMPOUND:
5604 case DATABASE:
5605 case CALL:
5606 case DDL:
5607 case DISASSOCIATE:
5608 case EACH:
5609 case FOLLOWS:
5610 case LOGOFF:
5611 case LOGON:
5612 case NESTED:
5613 case NOAUDIT:
5614 case SCHEMA:
5615 case SERVERERROR:
5616 case SHUTDOWN:
5617 case STARTUP:
5618 case STATEMENT:
5619 case STATISTICS:
5620 case SUSPEND:
5621 case TRUNCATE:
5622 case WRAPPED:
5623 case LIBRARY:
5624 case NAME:
5625 case STRUCT:
5626 case CONTEXT:
5627 case PARAMETERS:
5628 case LENGTH:
5629 case TDO:
5630 case MAXLEN:
5631 case CHARSETID:
5632 case CHARSETFORM:
5633 case ACCEPT:
5634 case ACCESSIBLE:
5635 case COPY:
5636 case DEFINE:
5637 case DISCONNECT:
5638 case HOST:
5639 case PRINT:
5640 case QUIT:
5641 case REMARK:
5642 case UNDEFINE:
5643 case VARIABLE:
5644 case WHENEVER:
5645 case ATTACH:
5646 case CAST:
5647 case TREAT:
5648 case TRIM:
5649 case LEFT:
5650 case RIGHT:
5651 case BOTH:
5652 case EMPTY:
5653 case MULTISET:
5654 case SUBMULTISET:
5655 case LEADING:
5656 case TRAILING:
5657 case CHAR_CS:
5658 case NCHAR_CS:
5659 case DBTIMEZONE:
5660 case SESSIONTIMEZONE:
5661 case AUTHENTICATED:
5662 case LINK:
5663 case SHARED:
5664 case DIRECTORY:
5665 case USER:
5666 case IDENTIFIER:
5667 case QUOTED_LITERAL:
5668 case SQLDATA_CLASS:
5669 case CUSTOMDATUM_CLASS:
5670 case ORADATA_CLASS:
5671 case JAVA_INTERFACE_CLASS:
5672 DeclarativeSection();
5673 jj_consume_token(BEGIN);
5674 switch (jj_nt.kind) {
5675 case PRAGMA:
5676 Pragma();
5677 break;
5678 default:
5679 jj_la1[64] = jj_gen;
5680 ;
5681 }
5682 label_16:
5683 while (true) {
5684 switch (jj_nt.kind) {
5685 case 5:
5686 case 16:
5687 case 17:
5688 case 21:
5689 case REPLACE:
5690 case DEFINER:
5691 case CURRENT_USER:
5692 case LANGUAGE:
5693 case INLINE:
5694 case ADD:
5695 case AGGREGATE:
5696 case ARRAY:
5697 case AT:
5698 case ATTRIBUTE:
5699 case AUTHID:
5700 case BEGIN:
5701 case BODY:
5702 case BULK:
5703 case BYTE:
5704 case CASCADE:
5705 case CASE:
5706 case CLOSE:
5707 case COALESCE:
5708 case COLLECT:
5709 case COLUMN:
5710 case COMMENT:
5711 case COMMIT:
5712 case CONSTRUCTOR:
5713 case CONTINUE:
5714 case CONVERT:
5715 case CURRENT:
5716 case CURSOR:
5717 case DATA:
5718 case DATE:
5719 case DAY:
5720 case DECLARE:
5721 case DELETE:
5722 case DISABLE:
5723 case EDITIONABLE:
5724 case ELEMENT:
5725 case ENABLE:
5726 case ESCAPE:
5727 case EXCEPT:
5728 case EXCEPTIONS:
5729 case EXECUTE:
5730 case EXIT:
5731 case EXTERNAL:
5732 case EXTENDS:
5733 case EXTRACT:
5734 case FALSE:
5735 case FETCH:
5736 case FINAL:
5737 case FOR:
5738 case FORALL:
5739 case FORCE:
5740 case FUNCTION:
5741 case GLOBAL:
5742 case GOTO:
5743 case HASH:
5744 case HEAP:
5745 case HOUR:
5746 case IF:
5747 case IMMEDIATE:
5748 case INDICES:
5749 case INDEXTYPE:
5750 case INDICATOR:
5751 case INSERT:
5752 case INSTANTIABLE:
5753 case INTERVAL:
5754 case INVALIDATE:
5755 case ISOLATION:
5756 case JAVA:
5757 case LEVEL:
5758 case LIMIT:
5759 case LOCK:
5760 case LOOP:
5761 case MAP:
5762 case MAX:
5763 case MEMBER:
5764 case MERGE:
5765 case MIN:
5766 case MINUTE:
5767 case MLSLABEL:
5768 case MODIFY:
5769 case MOD:
5770 case MONTH:
5771 case NATURAL:
5772 case NEW:
5773 case NEW_DOT:
5774 case NO:
5775 case NONEDITIONABLE:
5776 case NOT:
5777 case NULL:
5778 case NULLIF:
5779 case OBJECT:
5780 case OID:
5781 case OPAQUE:
5782 case OPEN:
5783 case OPERATOR:
5784 case ORGANIZATION:
5785 case OTHERS:
5786 case OVERRIDING:
5787 case PACKAGE:
5788 case PARTITION:
5789 case PIPE:
5790 case PRAGMA:
5791 case PRESERVE:
5792 case PRIVATE:
5793 case PROCEDURE:
5794 case RAISE:
5795 case RANGE:
5796 case RAW:
5797 case REAL:
5798 case RECORD:
5799 case REF:
5800 case RELEASE:
5801 case RELIES_ON:
5802 case RENAME:
5803 case RESULT:
5804 case RETURN:
5805 case RETURNING:
5806 case REVERSE:
5807 case ROLLBACK:
5808 case ROW:
5809 case ROWS:
5810 case ROWID:
5811 case ROWNUM:
5812 case SAVE:
5813 case SAVEPOINT:
5814 case SECOND:
5815 case SELECT:
5816 case SELF:
5817 case SET:
5818 case SPACE:
5819 case SQL:
5820 case SQLCODE:
5821 case SQLERRM:
5822 case STATIC:
5823 case SUBTYPE:
5824 case SUBSTITUTABLE:
5825 case SUCCESSFUL:
5826 case SYSDATE:
5827 case SYS_REFCURSOR:
5828 case TEMPORARY:
5829 case TIME:
5830 case TIMESTAMP:
5831 case TIMEZONE_REGION:
5832 case TIMEZONE_ABBR:
5833 case TIMEZONE_MINUTE:
5834 case TIMEZONE_HOUR:
5835 case TRANSACTION:
5836 case TRUE:
5837 case TYPE:
5838 case UNDER:
5839 case USING:
5840 case WHILE:
5841 case YES:
5842 case SHOW:
5843 case A:
5844 case UPDATE:
5845 case DOUBLE:
5846 case DEC:
5847 case PRECISION:
5848 case INT:
5849 case NUMERIC:
5850 case NCHAR:
5851 case NVARCHAR2:
5852 case STRING:
5853 case UROWID:
5854 case VARRAY:
5855 case VARYING:
5856 case BFILE:
5857 case BLOB:
5858 case CLOB:
5859 case NCLOB:
5860 case YEAR:
5861 case LOCAL:
5862 case WITH:
5863 case ZONE:
5864 case CHARACTER:
5865 case AFTER:
5866 case BEFORE:
5867 case OLD:
5868 case PARENT:
5869 case CC_IF:
5870 case CC_ERROR:
5871 case ANALYZE:
5872 case ASSOCIATE:
5873 case AUDIT:
5874 case COMPOUND:
5875 case DATABASE:
5876 case CALL:
5877 case DDL:
5878 case DISASSOCIATE:
5879 case EACH:
5880 case FOLLOWS:
5881 case LOGOFF:
5882 case LOGON:
5883 case NESTED:
5884 case NOAUDIT:
5885 case SCHEMA:
5886 case SERVERERROR:
5887 case SHUTDOWN:
5888 case STARTUP:
5889 case STATEMENT:
5890 case STATISTICS:
5891 case SUSPEND:
5892 case TRUNCATE:
5893 case WRAPPED:
5894 case LIBRARY:
5895 case NAME:
5896 case STRUCT:
5897 case CONTEXT:
5898 case PARAMETERS:
5899 case LENGTH:
5900 case TDO:
5901 case MAXLEN:
5902 case CHARSETID:
5903 case CHARSETFORM:
5904 case ACCEPT:
5905 case ACCESSIBLE:
5906 case COPY:
5907 case DEFINE:
5908 case DISCONNECT:
5909 case HOST:
5910 case PRINT:
5911 case QUIT:
5912 case REMARK:
5913 case UNDEFINE:
5914 case VARIABLE:
5915 case WHENEVER:
5916 case ATTACH:
5917 case CAST:
5918 case TREAT:
5919 case TRIM:
5920 case LEFT:
5921 case RIGHT:
5922 case BOTH:
5923 case EMPTY:
5924 case MULTISET:
5925 case SUBMULTISET:
5926 case LEADING:
5927 case TRAILING:
5928 case CHAR_CS:
5929 case NCHAR_CS:
5930 case DBTIMEZONE:
5931 case SESSIONTIMEZONE:
5932 case AUTHENTICATED:
5933 case LINK:
5934 case SHARED:
5935 case DIRECTORY:
5936 case USER:
5937 case IDENTIFIER:
5938 case UNSIGNED_NUMERIC_LITERAL:
5939 case CHARACTER_LITERAL:
5940 case STRING_LITERAL:
5941 case QUOTED_LITERAL:
5942 ;
5943 break;
5944 default:
5945 jj_la1[65] = jj_gen;
5946 break label_16;
5947 }
5948 Statement();
5949 }
5950 switch (jj_nt.kind) {
5951 case EXCEPTION:
5952 ExceptionHandler();
5953 break;
5954 default:
5955 jj_la1[66] = jj_gen;
5956 ;
5957 }
5958 jj_consume_token(END);
5959 switch (jj_nt.kind) {
5960 case REPLACE:
5961 case DEFINER:
5962 case CURRENT_USER:
5963 case SERIALLY_REUSABLE:
5964 case RESTRICT_REFERENCES:
5965 case EXCEPTION_INIT:
5966 case AUTONOMOUS_TRANSACTION:
5967 case LANGUAGE:
5968 case INLINE:
5969 case ADD:
5970 case AGGREGATE:
5971 case ALL:
5972 case ALTER:
5973 case AND:
5974 case ANY:
5975 case ARRAY:
5976 case AS:
5977 case ASC:
5978 case AT:
5979 case ATTRIBUTE:
5980 case AUTHID:
5981 case AVG:
5982 case BETWEEN:
5983 case BINARY_INTEGER:
5984 case BODY:
5985 case BOOLEAN:
5986 case BULK:
5987 case BY:
5988 case BYTE:
5989 case CASCADE:
5990 case CASE:
5991 case CHAR:
5992 case CHAR_BASE:
5993 case CHECK:
5994 case CLOSE:
5995 case CLUSTER:
5996 case COALESCE:
5997 case COLLECT:
5998 case COLUMN:
5999 case COMMENT:
6000 case COMMIT:
6001 case COMPRESS:
6002 case CONNECT:
6003 case CONSTANT:
6004 case CONSTRUCTOR:
6005 case CONTINUE:
6006 case CONVERT:
6007 case CREATE:
6008 case CURRENT:
6009 case CURRVAL:
6010 case CURSOR:
6011 case DATA:
6012 case DATE:
6013 case DAY:
6014 case DECLARE:
6015 case DECIMAL:
6016 case _DEFAULT:
6017 case DELETE:
6018 case DESC:
6019 case DISABLE:
6020 case DISTINCT:
6021 case DO:
6022 case DROP:
6023 case EDITIONABLE:
6024 case ELEMENT:
6025 case ELSE:
6026 case ELSIF:
6027 case ENABLE:
6028 case ESCAPE:
6029 case EXCEPT:
6030 case EXCEPTION:
6031 case EXCEPTIONS:
6032 case EXCLUSIVE:
6033 case EXECUTE:
6034 case EXISTS:
6035 case EXIT:
6036 case EXTERNAL:
6037 case EXTENDS:
6038 case EXTRACT:
6039 case FALSE:
6040 case FETCH:
6041 case FINAL:
6042 case FLOAT:
6043 case FOR:
6044 case FORALL:
6045 case FORCE:
6046 case FROM:
6047 case FUNCTION:
6048 case GLOBAL:
6049 case GOTO:
6050 case GROUP:
6051 case HASH:
6052 case HAVING:
6053 case HEAP:
6054 case HOUR:
6055 case IF:
6056 case IMMEDIATE:
6057 case IN:
6058 case INDEX:
6059 case INDICES:
6060 case INDEXTYPE:
6061 case INDICATOR:
6062 case INSERT:
6063 case INSTANTIABLE:
6064 case INTEGER:
6065 case INTERFACE:
6066 case INTERSECT:
6067 case INTERVAL:
6068 case INTO:
6069 case INVALIDATE:
6070 case IS:
6071 case ISOLATION:
6072 case JAVA:
6073 case LEVEL:
6074 case LIKE:
6075 case LIMIT:
6076 case LIMITED:
6077 case LOCK:
6078 case LONG:
6079 case LOOP:
6080 case MAP:
6081 case MAX:
6082 case MEMBER:
6083 case MERGE:
6084 case MIN:
6085 case MINUS:
6086 case MINUTE:
6087 case MLSLABEL:
6088 case MODIFY:
6089 case MOD:
6090 case MODE:
6091 case MONTH:
6092 case NATURAL:
6093 case NATURALN:
6094 case NEW:
6095 case NEXTVAL:
6096 case NO:
6097 case NOCOPY:
6098 case NONEDITIONABLE:
6099 case NOT:
6100 case NOWAIT:
6101 case NULL:
6102 case NULLIF:
6103 case NUMBER:
6104 case BFILE_BASE:
6105 case BLOB_BASE:
6106 case CLOB_BASE:
6107 case DATE_BASE:
6108 case NUMBER_BASE:
6109 case OBJECT:
6110 case OCIROWID:
6111 case OF:
6112 case OID:
6113 case ON:
6114 case OPAQUE:
6115 case OPEN:
6116 case OPERATOR:
6117 case OPTION:
6118 case OR:
6119 case ORDER:
6120 case ORGANIZATION:
6121 case OTHERS:
6122 case OUT:
6123 case OVERRIDING:
6124 case PACKAGE:
6125 case PARTITION:
6126 case PCTFREE:
6127 case PLS_INTEGER:
6128 case POSITIVE:
6129 case POSITIVEN:
6130 case PRESERVE:
6131 case PRIOR:
6132 case PROMPT:
6133 case PRIVATE:
6134 case PROCEDURE:
6135 case PUBLIC:
6136 case RAISE:
6137 case RANGE:
6138 case RAW:
6139 case REAL:
6140 case RECORD:
6141 case REF:
6142 case RELEASE:
6143 case RELIES_ON:
6144 case RENAME:
6145 case RESULT:
6146 case RETURN:
6147 case RETURNING:
6148 case REVERSE:
6149 case ROLLBACK:
6150 case ROW:
6151 case ROWS:
6152 case ROWID:
6153 case ROWNUM:
6154 case ROWTYPE:
6155 case SAVE:
6156 case SAVEPOINT:
6157 case SECOND:
6158 case SELECT:
6159 case SELF:
6160 case SEPARATE:
6161 case SET:
6162 case SHARE:
6163 case SMALLINT:
6164 case SPACE:
6165 case SQL:
6166 case SQLCODE:
6167 case SQLERRM:
6168 case START:
6169 case STATIC:
6170 case STDDEV:
6171 case SUBTYPE:
6172 case SUBSTITUTABLE:
6173 case SUCCESSFUL:
6174 case SUM:
6175 case SYNONYM:
6176 case SYSDATE:
6177 case SYS_REFCURSOR:
6178 case TABLE:
6179 case TEMPORARY:
6180 case THEN:
6181 case TIME:
6182 case TIMESTAMP:
6183 case TIMEZONE_REGION:
6184 case TIMEZONE_ABBR:
6185 case TIMEZONE_MINUTE:
6186 case TIMEZONE_HOUR:
6187 case TO:
6188 case TRANSACTION:
6189 case TRIGGER:
6190 case TRUE:
6191 case TYPE:
6192 case UI:
6193 case UNDER:
6194 case USING:
6195 case WHILE:
6196 case YES:
6197 case SHOW:
6198 case A:
6199 case UPDATE:
6200 case VARCHAR:
6201 case VARCHAR2:
6202 case DOUBLE:
6203 case DEC:
6204 case PRECISION:
6205 case INT:
6206 case NUMERIC:
6207 case SIGNTYPE:
6208 case NCHAR:
6209 case NVARCHAR2:
6210 case STRING:
6211 case UROWID:
6212 case VARRAY:
6213 case VARYING:
6214 case BFILE:
6215 case BLOB:
6216 case CLOB:
6217 case NCLOB:
6218 case YEAR:
6219 case LOCAL:
6220 case WITH:
6221 case ZONE:
6222 case CHARACTER:
6223 case AFTER:
6224 case BEFORE:
6225 case OLD:
6226 case PARENT:
6227 case ANALYZE:
6228 case ASSOCIATE:
6229 case AUDIT:
6230 case COMPOUND:
6231 case DATABASE:
6232 case CALL:
6233 case DDL:
6234 case DISASSOCIATE:
6235 case EACH:
6236 case FOLLOWS:
6237 case LOGOFF:
6238 case LOGON:
6239 case NESTED:
6240 case NOAUDIT:
6241 case SCHEMA:
6242 case SERVERERROR:
6243 case SHUTDOWN:
6244 case STARTUP:
6245 case STATEMENT:
6246 case STATISTICS:
6247 case SUSPEND:
6248 case TRUNCATE:
6249 case WRAPPED:
6250 case LIBRARY:
6251 case NAME:
6252 case STRUCT:
6253 case CONTEXT:
6254 case PARAMETERS:
6255 case LENGTH:
6256 case TDO:
6257 case MAXLEN:
6258 case CHARSETID:
6259 case CHARSETFORM:
6260 case ACCEPT:
6261 case ACCESSIBLE:
6262 case COPY:
6263 case DEFINE:
6264 case DISCONNECT:
6265 case HOST:
6266 case PRINT:
6267 case QUIT:
6268 case REMARK:
6269 case UNDEFINE:
6270 case VARIABLE:
6271 case WHENEVER:
6272 case ATTACH:
6273 case CAST:
6274 case TREAT:
6275 case TRIM:
6276 case LEFT:
6277 case RIGHT:
6278 case BOTH:
6279 case EMPTY:
6280 case MULTISET:
6281 case SUBMULTISET:
6282 case LEADING:
6283 case TRAILING:
6284 case CHAR_CS:
6285 case NCHAR_CS:
6286 case DBTIMEZONE:
6287 case SESSIONTIMEZONE:
6288 case AUTHENTICATED:
6289 case LINK:
6290 case SHARED:
6291 case DIRECTORY:
6292 case USER:
6293 case IDENTIFIER:
6294 case QUOTED_LITERAL:
6295 case SQLDATA_CLASS:
6296 case CUSTOMDATUM_CLASS:
6297 case ORADATA_CLASS:
6298 case JAVA_INTERFACE_CLASS:
6299 ID();
6300 break;
6301 default:
6302 jj_la1[67] = jj_gen;
6303 ;
6304 }
6305 break;
6306 default:
6307 jj_la1[68] = jj_gen;
6308 jj_consume_token(-1);
6309 throw new ParseException();
6310 }
6311 }
6312 break;
6313 default:
6314 jj_la1[69] = jj_gen;
6315 ;
6316 }
6317 jj_consume_token(4);
6318 break;
6319 default:
6320 jj_la1[70] = jj_gen;
6321 jj_consume_token(-1);
6322 throw new ParseException();
6323 }
6324 jjtree.closeNodeScope(jjtn000, true);
6325 jjtc000 = false;
6326 {if (true) return jjtn000 ;}
6327 } catch (Throwable jjte000) {
6328 if (jjtc000) {
6329 jjtree.clearNodeScope(jjtn000);
6330 jjtc000 = false;
6331 } else {
6332 jjtree.popNode();
6333 }
6334 if (jjte000 instanceof RuntimeException) {
6335 {if (true) throw (RuntimeException)jjte000;}
6336 }
6337 if (jjte000 instanceof ParseException) {
6338 {if (true) throw (ParseException)jjte000;}
6339 }
6340 {if (true) throw (Error)jjte000;}
6341 } finally {
6342 if (jjtc000) {
6343 jjtree.closeNodeScope(jjtn000, true);
6344 }
6345 }
6346 throw new Error("Missing return statement in function");
6347 }
6348
6349 final public ASTObjectNameDeclaration ObjectNameDeclaration() throws ParseException {
6350
6351 ASTObjectNameDeclaration jjtn000 = new ASTObjectNameDeclaration(this, JJTOBJECTNAMEDECLARATION);
6352 boolean jjtc000 = true;
6353 jjtree.openNodeScope(jjtn000);PLSQLNode schemaName = null, objectName = null ;
6354 try {
6355 if (jj_2_22(2)) {
6356 schemaName = ID();
6357 jj_consume_token(3);
6358 } else {
6359 ;
6360 }
6361 objectName = ID();
6362 jjtn000.setImage( (null == schemaName) ? objectName.getImage() : (schemaName.getImage() + "." + objectName.getImage() ) ) ;
6363 jjtree.closeNodeScope(jjtn000, true);
6364 jjtc000 = false;
6365 {if (true) return jjtn000 ;}
6366 } catch (Throwable jjte000) {
6367 if (jjtc000) {
6368 jjtree.clearNodeScope(jjtn000);
6369 jjtc000 = false;
6370 } else {
6371 jjtree.popNode();
6372 }
6373 if (jjte000 instanceof RuntimeException) {
6374 {if (true) throw (RuntimeException)jjte000;}
6375 }
6376 if (jjte000 instanceof ParseException) {
6377 {if (true) throw (ParseException)jjte000;}
6378 }
6379 {if (true) throw (Error)jjte000;}
6380 } finally {
6381 if (jjtc000) {
6382 jjtree.closeNodeScope(jjtn000, true);
6383 }
6384 }
6385 throw new Error("Missing return statement in function");
6386 }
6387
6388 final public ASTFormalParameter FormalParameter() throws ParseException {
6389
6390 ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
6391 boolean jjtc000 = true;
6392 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6393 try {
6394 simpleNode = ID();
6395 if (jj_2_25(2)) {
6396 if (jj_2_24(2)) {
6397 switch (jj_nt.kind) {
6398 case OUT:
6399 jj_consume_token(OUT);
6400 break;
6401 case IN:
6402 jj_consume_token(IN);
6403 jj_consume_token(OUT);
6404 break;
6405 default:
6406 jj_la1[71] = jj_gen;
6407 jj_consume_token(-1);
6408 throw new ParseException();
6409 }
6410 if (jj_2_23(2)) {
6411 jj_consume_token(NOCOPY);
6412 } else {
6413 ;
6414 }
6415 } else {
6416 switch (jj_nt.kind) {
6417 case IN:
6418 jj_consume_token(IN);
6419 break;
6420 default:
6421 jj_la1[72] = jj_gen;
6422 jj_consume_token(-1);
6423 throw new ParseException();
6424 }
6425 }
6426 } else {
6427 ;
6428 }
6429 switch (jj_nt.kind) {
6430 case 8:
6431 jj_consume_token(8);
6432 break;
6433 case REPLACE:
6434 case DEFINER:
6435 case CURRENT_USER:
6436 case LANGUAGE:
6437 case INLINE:
6438 case ADD:
6439 case AGGREGATE:
6440 case ARRAY:
6441 case AT:
6442 case ATTRIBUTE:
6443 case AUTHID:
6444 case BINARY_INTEGER:
6445 case BODY:
6446 case BOOLEAN:
6447 case BULK:
6448 case BYTE:
6449 case CASCADE:
6450 case CHAR:
6451 case CHAR_BASE:
6452 case CLOSE:
6453 case COALESCE:
6454 case COLLECT:
6455 case COLUMN:
6456 case COMMENT:
6457 case COMMIT:
6458 case CONSTRUCTOR:
6459 case CONTINUE:
6460 case CONVERT:
6461 case CURRENT:
6462 case CURSOR:
6463 case DATA:
6464 case DATE:
6465 case DAY:
6466 case DECIMAL:
6467 case DISABLE:
6468 case EDITIONABLE:
6469 case ELEMENT:
6470 case ENABLE:
6471 case ESCAPE:
6472 case EXCEPT:
6473 case EXCEPTIONS:
6474 case EXIT:
6475 case EXTERNAL:
6476 case EXTENDS:
6477 case EXTRACT:
6478 case FALSE:
6479 case FINAL:
6480 case FLOAT:
6481 case FORCE:
6482 case FUNCTION:
6483 case GLOBAL:
6484 case HASH:
6485 case HEAP:
6486 case HOUR:
6487 case IMMEDIATE:
6488 case INDICES:
6489 case INDEXTYPE:
6490 case INDICATOR:
6491 case INSTANTIABLE:
6492 case INTEGER:
6493 case INTERVAL:
6494 case INVALIDATE:
6495 case ISOLATION:
6496 case JAVA:
6497 case LEVEL:
6498 case LIMIT:
6499 case LONG:
6500 case LOOP:
6501 case MAP:
6502 case MAX:
6503 case MEMBER:
6504 case MERGE:
6505 case MIN:
6506 case MINUTE:
6507 case MLSLABEL:
6508 case MODIFY:
6509 case MOD:
6510 case MONTH:
6511 case NATURAL:
6512 case NATURALN:
6513 case NEW:
6514 case NO:
6515 case NONEDITIONABLE:
6516 case NULLIF:
6517 case NUMBER:
6518 case BFILE_BASE:
6519 case BLOB_BASE:
6520 case CLOB_BASE:
6521 case DATE_BASE:
6522 case NUMBER_BASE:
6523 case OBJECT:
6524 case OID:
6525 case OPAQUE:
6526 case OPEN:
6527 case OPERATOR:
6528 case ORGANIZATION:
6529 case OTHERS:
6530 case OVERRIDING:
6531 case PACKAGE:
6532 case PARTITION:
6533 case PLS_INTEGER:
6534 case POSITIVE:
6535 case POSITIVEN:
6536 case PRESERVE:
6537 case PRIVATE:
6538 case PROCEDURE:
6539 case RANGE:
6540 case RAW:
6541 case REAL:
6542 case RECORD:
6543 case REF:
6544 case RELEASE:
6545 case RELIES_ON:
6546 case RENAME:
6547 case RESULT:
6548 case RETURN:
6549 case RETURNING:
6550 case REVERSE:
6551 case ROLLBACK:
6552 case ROW:
6553 case ROWS:
6554 case ROWID:
6555 case ROWNUM:
6556 case SAVE:
6557 case SAVEPOINT:
6558 case SECOND:
6559 case SELF:
6560 case SET:
6561 case SMALLINT:
6562 case SPACE:
6563 case SQL:
6564 case SQLCODE:
6565 case SQLERRM:
6566 case STATIC:
6567 case SUBTYPE:
6568 case SUBSTITUTABLE:
6569 case SUCCESSFUL:
6570 case SYSDATE:
6571 case SYS_REFCURSOR:
6572 case TEMPORARY:
6573 case TIME:
6574 case TIMESTAMP:
6575 case TIMEZONE_REGION:
6576 case TIMEZONE_ABBR:
6577 case TIMEZONE_MINUTE:
6578 case TIMEZONE_HOUR:
6579 case TRANSACTION:
6580 case TRUE:
6581 case TYPE:
6582 case UNDER:
6583 case USING:
6584 case YES:
6585 case SHOW:
6586 case A:
6587 case VARCHAR:
6588 case VARCHAR2:
6589 case DOUBLE:
6590 case DEC:
6591 case PRECISION:
6592 case INT:
6593 case NUMERIC:
6594 case SIGNTYPE:
6595 case NCHAR:
6596 case NVARCHAR2:
6597 case STRING:
6598 case UROWID:
6599 case VARRAY:
6600 case VARYING:
6601 case BFILE:
6602 case BLOB:
6603 case CLOB:
6604 case NCLOB:
6605 case YEAR:
6606 case LOCAL:
6607 case ZONE:
6608 case CHARACTER:
6609 case AFTER:
6610 case BEFORE:
6611 case OLD:
6612 case PARENT:
6613 case CC_IF:
6614 case ANALYZE:
6615 case ASSOCIATE:
6616 case AUDIT:
6617 case COMPOUND:
6618 case DATABASE:
6619 case CALL:
6620 case DDL:
6621 case DISASSOCIATE:
6622 case EACH:
6623 case FOLLOWS:
6624 case LOGOFF:
6625 case LOGON:
6626 case NESTED:
6627 case NOAUDIT:
6628 case SCHEMA:
6629 case SERVERERROR:
6630 case SHUTDOWN:
6631 case STARTUP:
6632 case STATEMENT:
6633 case STATISTICS:
6634 case SUSPEND:
6635 case TRUNCATE:
6636 case WRAPPED:
6637 case LIBRARY:
6638 case NAME:
6639 case STRUCT:
6640 case CONTEXT:
6641 case PARAMETERS:
6642 case LENGTH:
6643 case TDO:
6644 case MAXLEN:
6645 case CHARSETID:
6646 case CHARSETFORM:
6647 case ACCEPT:
6648 case ACCESSIBLE:
6649 case COPY:
6650 case DEFINE:
6651 case DISCONNECT:
6652 case HOST:
6653 case PRINT:
6654 case QUIT:
6655 case REMARK:
6656 case UNDEFINE:
6657 case VARIABLE:
6658 case WHENEVER:
6659 case ATTACH:
6660 case CAST:
6661 case TREAT:
6662 case TRIM:
6663 case LEFT:
6664 case RIGHT:
6665 case BOTH:
6666 case EMPTY:
6667 case MULTISET:
6668 case SUBMULTISET:
6669 case LEADING:
6670 case TRAILING:
6671 case CHAR_CS:
6672 case NCHAR_CS:
6673 case DBTIMEZONE:
6674 case SESSIONTIMEZONE:
6675 case AUTHENTICATED:
6676 case LINK:
6677 case SHARED:
6678 case DIRECTORY:
6679 case USER:
6680 case IDENTIFIER:
6681 case QUOTED_LITERAL:
6682 Datatype();
6683 break;
6684 default:
6685 jj_la1[73] = jj_gen;
6686 jj_consume_token(-1);
6687 throw new ParseException();
6688 }
6689 switch (jj_nt.kind) {
6690 case 9:
6691 case _DEFAULT:
6692 switch (jj_nt.kind) {
6693 case 9:
6694 jj_consume_token(9);
6695 jj_consume_token(10);
6696 break;
6697 case _DEFAULT:
6698 jj_consume_token(_DEFAULT);
6699 break;
6700 default:
6701 jj_la1[74] = jj_gen;
6702 jj_consume_token(-1);
6703 throw new ParseException();
6704 }
6705 Expression();
6706 break;
6707 default:
6708 jj_la1[75] = jj_gen;
6709 ;
6710 }
6711 jjtree.closeNodeScope(jjtn000, true);
6712 jjtc000 = false;
6713 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
6714 } catch (Throwable jjte000) {
6715 if (jjtc000) {
6716 jjtree.clearNodeScope(jjtn000);
6717 jjtc000 = false;
6718 } else {
6719 jjtree.popNode();
6720 }
6721 if (jjte000 instanceof RuntimeException) {
6722 {if (true) throw (RuntimeException)jjte000;}
6723 }
6724 if (jjte000 instanceof ParseException) {
6725 {if (true) throw (ParseException)jjte000;}
6726 }
6727 {if (true) throw (Error)jjte000;}
6728 } finally {
6729 if (jjtc000) {
6730 jjtree.closeNodeScope(jjtn000, true);
6731 }
6732 }
6733 throw new Error("Missing return statement in function");
6734 }
6735
6736 final public ASTMethodDeclaration MethodDeclaration() throws ParseException {
6737
6738 ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
6739 boolean jjtc000 = true;
6740 jjtree.openNodeScope(jjtn000);
6741 try {
6742 switch (jj_nt.kind) {
6743 case CREATE:
6744 case FUNCTION:
6745 case PROCEDURE:
6746 ProgramUnit();
6747 break;
6748 case CONSTRUCTOR:
6749 case FINAL:
6750 case INSTANTIABLE:
6751 case MAP:
6752 case MEMBER:
6753 case NOT:
6754 case ORDER:
6755 case OVERRIDING:
6756 case STATIC:
6757 TypeMethod();
6758 break;
6759 default:
6760 jj_la1[76] = jj_gen;
6761 jj_consume_token(-1);
6762 throw new ParseException();
6763 }
6764 jjtree.closeNodeScope(jjtn000, true);
6765 jjtc000 = false;
6766 {if (true) return jjtn000 ;}
6767 } catch (Throwable jjte000) {
6768 if (jjtc000) {
6769 jjtree.clearNodeScope(jjtn000);
6770 jjtc000 = false;
6771 } else {
6772 jjtree.popNode();
6773 }
6774 if (jjte000 instanceof RuntimeException) {
6775 {if (true) throw (RuntimeException)jjte000;}
6776 }
6777 if (jjte000 instanceof ParseException) {
6778 {if (true) throw (ParseException)jjte000;}
6779 }
6780 {if (true) throw (Error)jjte000;}
6781 } finally {
6782 if (jjtc000) {
6783 jjtree.closeNodeScope(jjtn000, true);
6784 }
6785 }
6786 throw new Error("Missing return statement in function");
6787 }
6788
6789 final public ASTMethodDeclarator MethodDeclarator() throws ParseException {
6790
6791 ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
6792 boolean jjtc000 = true;
6793 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6794 try {
6795 switch (jj_nt.kind) {
6796 case FUNCTION:
6797 jj_consume_token(FUNCTION);
6798 simpleNode = ObjectNameDeclaration();
6799 switch (jj_nt.kind) {
6800 case 5:
6801 FormalParameters();
6802 break;
6803 default:
6804 jj_la1[77] = jj_gen;
6805 ;
6806 }
6807 Token nextToken;
6808 nextToken = getToken(1);
6809 if (!nextToken.image.equalsIgnoreCase("WRAPPED")
6810 &&
6811 !nextToken.image.equalsIgnoreCase("RETURN")
6812 )
6813 {
6814 {if (true) throw new ParseException("FUNCTION must RETURN a value or must be WRAPPED : found \u005c""
6815 + nextToken.image
6816 + "\u005c" at line "+nextToken.beginLine
6817 + ", column "+nextToken.beginColumn
6818 );}
6819 }
6820 switch (jj_nt.kind) {
6821 case RETURN:
6822 jj_consume_token(RETURN);
6823 Datatype();
6824 break;
6825 default:
6826 jj_la1[78] = jj_gen;
6827 ;
6828 }
6829 break;
6830 case PROCEDURE:
6831 jj_consume_token(PROCEDURE);
6832 simpleNode = ObjectNameDeclaration();
6833 switch (jj_nt.kind) {
6834 case 5:
6835 FormalParameters();
6836 break;
6837 default:
6838 jj_la1[79] = jj_gen;
6839 ;
6840 }
6841 break;
6842 default:
6843 jj_la1[80] = jj_gen;
6844 jj_consume_token(-1);
6845 throw new ParseException();
6846 }
6847 jjtree.closeNodeScope(jjtn000, true);
6848 jjtc000 = false;
6849 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
6850 } catch (Throwable jjte000) {
6851 if (jjtc000) {
6852 jjtree.clearNodeScope(jjtn000);
6853 jjtc000 = false;
6854 } else {
6855 jjtree.popNode();
6856 }
6857 if (jjte000 instanceof RuntimeException) {
6858 {if (true) throw (RuntimeException)jjte000;}
6859 }
6860 if (jjte000 instanceof ParseException) {
6861 {if (true) throw (ParseException)jjte000;}
6862 }
6863 {if (true) throw (Error)jjte000;}
6864 } finally {
6865 if (jjtc000) {
6866 jjtree.closeNodeScope(jjtn000, true);
6867 }
6868 }
6869 throw new Error("Missing return statement in function");
6870 }
6871
6872 final public ASTFormalParameters FormalParameters() throws ParseException {
6873
6874 ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
6875 boolean jjtc000 = true;
6876 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6877 StringBuilder sb = new StringBuilder();
6878 try {
6879 jj_consume_token(5);
6880 sb.append("(");
6881 switch (jj_nt.kind) {
6882 case REPLACE:
6883 case DEFINER:
6884 case CURRENT_USER:
6885 case SERIALLY_REUSABLE:
6886 case RESTRICT_REFERENCES:
6887 case EXCEPTION_INIT:
6888 case AUTONOMOUS_TRANSACTION:
6889 case LANGUAGE:
6890 case INLINE:
6891 case ADD:
6892 case AGGREGATE:
6893 case ALL:
6894 case ALTER:
6895 case AND:
6896 case ANY:
6897 case ARRAY:
6898 case AS:
6899 case ASC:
6900 case AT:
6901 case ATTRIBUTE:
6902 case AUTHID:
6903 case AVG:
6904 case BETWEEN:
6905 case BINARY_INTEGER:
6906 case BODY:
6907 case BOOLEAN:
6908 case BULK:
6909 case BY:
6910 case BYTE:
6911 case CASCADE:
6912 case CASE:
6913 case CHAR:
6914 case CHAR_BASE:
6915 case CHECK:
6916 case CLOSE:
6917 case CLUSTER:
6918 case COALESCE:
6919 case COLLECT:
6920 case COLUMN:
6921 case COMMENT:
6922 case COMMIT:
6923 case COMPRESS:
6924 case CONNECT:
6925 case CONSTANT:
6926 case CONSTRUCTOR:
6927 case CONTINUE:
6928 case CONVERT:
6929 case CREATE:
6930 case CURRENT:
6931 case CURRVAL:
6932 case CURSOR:
6933 case DATA:
6934 case DATE:
6935 case DAY:
6936 case DECLARE:
6937 case DECIMAL:
6938 case _DEFAULT:
6939 case DELETE:
6940 case DESC:
6941 case DISABLE:
6942 case DISTINCT:
6943 case DO:
6944 case DROP:
6945 case EDITIONABLE:
6946 case ELEMENT:
6947 case ELSE:
6948 case ELSIF:
6949 case ENABLE:
6950 case ESCAPE:
6951 case EXCEPT:
6952 case EXCEPTION:
6953 case EXCEPTIONS:
6954 case EXCLUSIVE:
6955 case EXECUTE:
6956 case EXISTS:
6957 case EXIT:
6958 case EXTERNAL:
6959 case EXTENDS:
6960 case EXTRACT:
6961 case FALSE:
6962 case FETCH:
6963 case FINAL:
6964 case FLOAT:
6965 case FOR:
6966 case FORALL:
6967 case FORCE:
6968 case FROM:
6969 case FUNCTION:
6970 case GLOBAL:
6971 case GOTO:
6972 case GROUP:
6973 case HASH:
6974 case HAVING:
6975 case HEAP:
6976 case HOUR:
6977 case IF:
6978 case IMMEDIATE:
6979 case IN:
6980 case INDEX:
6981 case INDICES:
6982 case INDEXTYPE:
6983 case INDICATOR:
6984 case INSERT:
6985 case INSTANTIABLE:
6986 case INTEGER:
6987 case INTERFACE:
6988 case INTERSECT:
6989 case INTERVAL:
6990 case INTO:
6991 case INVALIDATE:
6992 case IS:
6993 case ISOLATION:
6994 case JAVA:
6995 case LEVEL:
6996 case LIKE:
6997 case LIMIT:
6998 case LIMITED:
6999 case LOCK:
7000 case LONG:
7001 case LOOP:
7002 case MAP:
7003 case MAX:
7004 case MEMBER:
7005 case MERGE:
7006 case MIN:
7007 case MINUS:
7008 case MINUTE:
7009 case MLSLABEL:
7010 case MODIFY:
7011 case MOD:
7012 case MODE:
7013 case MONTH:
7014 case NATURAL:
7015 case NATURALN:
7016 case NEW:
7017 case NEXTVAL:
7018 case NO:
7019 case NOCOPY:
7020 case NONEDITIONABLE:
7021 case NOT:
7022 case NOWAIT:
7023 case NULL:
7024 case NULLIF:
7025 case NUMBER:
7026 case BFILE_BASE:
7027 case BLOB_BASE:
7028 case CLOB_BASE:
7029 case DATE_BASE:
7030 case NUMBER_BASE:
7031 case OBJECT:
7032 case OCIROWID:
7033 case OF:
7034 case OID:
7035 case ON:
7036 case OPAQUE:
7037 case OPEN:
7038 case OPERATOR:
7039 case OPTION:
7040 case OR:
7041 case ORDER:
7042 case ORGANIZATION:
7043 case OTHERS:
7044 case OUT:
7045 case OVERRIDING:
7046 case PACKAGE:
7047 case PARTITION:
7048 case PCTFREE:
7049 case PLS_INTEGER:
7050 case POSITIVE:
7051 case POSITIVEN:
7052 case PRESERVE:
7053 case PRIOR:
7054 case PROMPT:
7055 case PRIVATE:
7056 case PROCEDURE:
7057 case PUBLIC:
7058 case RAISE:
7059 case RANGE:
7060 case RAW:
7061 case REAL:
7062 case RECORD:
7063 case REF:
7064 case RELEASE:
7065 case RELIES_ON:
7066 case RENAME:
7067 case RESULT:
7068 case RETURN:
7069 case RETURNING:
7070 case REVERSE:
7071 case ROLLBACK:
7072 case ROW:
7073 case ROWS:
7074 case ROWID:
7075 case ROWNUM:
7076 case ROWTYPE:
7077 case SAVE:
7078 case SAVEPOINT:
7079 case SECOND:
7080 case SELECT:
7081 case SELF:
7082 case SEPARATE:
7083 case SET:
7084 case SHARE:
7085 case SMALLINT:
7086 case SPACE:
7087 case SQL:
7088 case SQLCODE:
7089 case SQLERRM:
7090 case START:
7091 case STATIC:
7092 case STDDEV:
7093 case SUBTYPE:
7094 case SUBSTITUTABLE:
7095 case SUCCESSFUL:
7096 case SUM:
7097 case SYNONYM:
7098 case SYSDATE:
7099 case SYS_REFCURSOR:
7100 case TABLE:
7101 case TEMPORARY:
7102 case THEN:
7103 case TIME:
7104 case TIMESTAMP:
7105 case TIMEZONE_REGION:
7106 case TIMEZONE_ABBR:
7107 case TIMEZONE_MINUTE:
7108 case TIMEZONE_HOUR:
7109 case TO:
7110 case TRANSACTION:
7111 case TRIGGER:
7112 case TRUE:
7113 case TYPE:
7114 case UI:
7115 case UNDER:
7116 case USING:
7117 case WHILE:
7118 case YES:
7119 case SHOW:
7120 case A:
7121 case UPDATE:
7122 case VARCHAR:
7123 case VARCHAR2:
7124 case DOUBLE:
7125 case DEC:
7126 case PRECISION:
7127 case INT:
7128 case NUMERIC:
7129 case SIGNTYPE:
7130 case NCHAR:
7131 case NVARCHAR2:
7132 case STRING:
7133 case UROWID:
7134 case VARRAY:
7135 case VARYING:
7136 case BFILE:
7137 case BLOB:
7138 case CLOB:
7139 case NCLOB:
7140 case YEAR:
7141 case LOCAL:
7142 case WITH:
7143 case ZONE:
7144 case CHARACTER:
7145 case AFTER:
7146 case BEFORE:
7147 case OLD:
7148 case PARENT:
7149 case ANALYZE:
7150 case ASSOCIATE:
7151 case AUDIT:
7152 case COMPOUND:
7153 case DATABASE:
7154 case CALL:
7155 case DDL:
7156 case DISASSOCIATE:
7157 case EACH:
7158 case FOLLOWS:
7159 case LOGOFF:
7160 case LOGON:
7161 case NESTED:
7162 case NOAUDIT:
7163 case SCHEMA:
7164 case SERVERERROR:
7165 case SHUTDOWN:
7166 case STARTUP:
7167 case STATEMENT:
7168 case STATISTICS:
7169 case SUSPEND:
7170 case TRUNCATE:
7171 case WRAPPED:
7172 case LIBRARY:
7173 case NAME:
7174 case STRUCT:
7175 case CONTEXT:
7176 case PARAMETERS:
7177 case LENGTH:
7178 case TDO:
7179 case MAXLEN:
7180 case CHARSETID:
7181 case CHARSETFORM:
7182 case ACCEPT:
7183 case ACCESSIBLE:
7184 case COPY:
7185 case DEFINE:
7186 case DISCONNECT:
7187 case HOST:
7188 case PRINT:
7189 case QUIT:
7190 case REMARK:
7191 case UNDEFINE:
7192 case VARIABLE:
7193 case WHENEVER:
7194 case ATTACH:
7195 case CAST:
7196 case TREAT:
7197 case TRIM:
7198 case LEFT:
7199 case RIGHT:
7200 case BOTH:
7201 case EMPTY:
7202 case MULTISET:
7203 case SUBMULTISET:
7204 case LEADING:
7205 case TRAILING:
7206 case CHAR_CS:
7207 case NCHAR_CS:
7208 case DBTIMEZONE:
7209 case SESSIONTIMEZONE:
7210 case AUTHENTICATED:
7211 case LINK:
7212 case SHARED:
7213 case DIRECTORY:
7214 case USER:
7215 case IDENTIFIER:
7216 case QUOTED_LITERAL:
7217 case SQLDATA_CLASS:
7218 case CUSTOMDATUM_CLASS:
7219 case ORADATA_CLASS:
7220 case JAVA_INTERFACE_CLASS:
7221 simpleNode = FormalParameter();
7222 sb.append(simpleNode.getImage());
7223 label_17:
7224 while (true) {
7225 switch (jj_nt.kind) {
7226 case 6:
7227 ;
7228 break;
7229 default:
7230 jj_la1[81] = jj_gen;
7231 break label_17;
7232 }
7233 jj_consume_token(6);
7234 simpleNode = FormalParameter();
7235 sb.append(","+simpleNode.getImage());
7236 }
7237 break;
7238 default:
7239 jj_la1[82] = jj_gen;
7240 ;
7241 }
7242 jj_consume_token(7);
7243 sb.append(")");
7244 jjtree.closeNodeScope(jjtn000, true);
7245 jjtc000 = false;
7246 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
7247 } catch (Throwable jjte000) {
7248 if (jjtc000) {
7249 jjtree.clearNodeScope(jjtn000);
7250 jjtc000 = false;
7251 } else {
7252 jjtree.popNode();
7253 }
7254 if (jjte000 instanceof RuntimeException) {
7255 {if (true) throw (RuntimeException)jjte000;}
7256 }
7257 if (jjte000 instanceof ParseException) {
7258 {if (true) throw (ParseException)jjte000;}
7259 }
7260 {if (true) throw (Error)jjte000;}
7261 } finally {
7262 if (jjtc000) {
7263 jjtree.closeNodeScope(jjtn000, true);
7264 }
7265 }
7266 throw new Error("Missing return statement in function");
7267 }
7268
7269 final public ASTVariableOrConstantDeclarator VariableOrConstantDeclarator() throws ParseException {
7270
7271 ASTVariableOrConstantDeclarator jjtn000 = new ASTVariableOrConstantDeclarator(this, JJTVARIABLEORCONSTANTDECLARATOR);
7272 boolean jjtc000 = true;
7273 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7274 StringBuilder sb = new StringBuilder();
7275 try {
7276 simpleNode = VariableOrConstantDeclaratorId();
7277 sb.append(simpleNode.getImage());
7278 if (jj_2_26(2)) {
7279 jj_consume_token(CONSTANT);
7280 sb.append(" " + token.image);
7281 } else {
7282 ;
7283 }
7284 simpleNode = Datatype();
7285 sb.append(" " + simpleNode.getImage());
7286 switch (jj_nt.kind) {
7287 case NOT:
7288 case NULL:
7289 switch (jj_nt.kind) {
7290 case NOT:
7291 jj_consume_token(NOT);
7292 sb.append(" " + token.image);
7293 break;
7294 default:
7295 jj_la1[83] = jj_gen;
7296 ;
7297 }
7298 jj_consume_token(NULL);
7299 sb.append(" " + token.image);
7300 break;
7301 default:
7302 jj_la1[84] = jj_gen;
7303 ;
7304 }
7305 switch (jj_nt.kind) {
7306 case 9:
7307 case _DEFAULT:
7308 switch (jj_nt.kind) {
7309 case 9:
7310 jj_consume_token(9);
7311 jj_consume_token(10);
7312 sb.append(" :=");
7313 break;
7314 case _DEFAULT:
7315 jj_consume_token(_DEFAULT);
7316 sb.append(" " + token.image);
7317 break;
7318 default:
7319 jj_la1[85] = jj_gen;
7320 jj_consume_token(-1);
7321 throw new ParseException();
7322 }
7323 simpleNode = VariableOrConstantInitializer();
7324 sb.append(" " + simpleNode.getImage());
7325 break;
7326 default:
7327 jj_la1[86] = jj_gen;
7328 ;
7329 }
7330 jjtree.closeNodeScope(jjtn000, true);
7331 jjtc000 = false;
7332 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
7333 } catch (Throwable jjte000) {
7334 if (jjtc000) {
7335 jjtree.clearNodeScope(jjtn000);
7336 jjtc000 = false;
7337 } else {
7338 jjtree.popNode();
7339 }
7340 if (jjte000 instanceof RuntimeException) {
7341 {if (true) throw (RuntimeException)jjte000;}
7342 }
7343 if (jjte000 instanceof ParseException) {
7344 {if (true) throw (ParseException)jjte000;}
7345 }
7346 {if (true) throw (Error)jjte000;}
7347 } finally {
7348 if (jjtc000) {
7349 jjtree.closeNodeScope(jjtn000, true);
7350 }
7351 }
7352 throw new Error("Missing return statement in function");
7353 }
7354
7355 final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
7356
7357 ASTVariableOrConstantDeclaratorId jjtn000 = new ASTVariableOrConstantDeclaratorId(this, JJTVARIABLEORCONSTANTDECLARATORID);
7358 boolean jjtc000 = true;
7359 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7360 try {
7361 simpleNode = ID();
7362 jjtree.closeNodeScope(jjtn000, true);
7363 jjtc000 = false;
7364 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
7365 } catch (Throwable jjte000) {
7366 if (jjtc000) {
7367 jjtree.clearNodeScope(jjtn000);
7368 jjtc000 = false;
7369 } else {
7370 jjtree.popNode();
7371 }
7372 if (jjte000 instanceof RuntimeException) {
7373 {if (true) throw (RuntimeException)jjte000;}
7374 }
7375 if (jjte000 instanceof ParseException) {
7376 {if (true) throw (ParseException)jjte000;}
7377 }
7378 {if (true) throw (Error)jjte000;}
7379 } finally {
7380 if (jjtc000) {
7381 jjtree.closeNodeScope(jjtn000, true);
7382 }
7383 }
7384 throw new Error("Missing return statement in function");
7385 }
7386
7387 final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
7388
7389 ASTVariableOrConstantInitializer jjtn000 = new ASTVariableOrConstantInitializer(this, JJTVARIABLEORCONSTANTINITIALIZER);
7390 boolean jjtc000 = true;
7391 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7392 try {
7393 simpleNode = Expression();
7394 jjtree.closeNodeScope(jjtn000, true);
7395 jjtc000 = false;
7396 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
7397 } catch (Throwable jjte000) {
7398 if (jjtc000) {
7399 jjtree.clearNodeScope(jjtn000);
7400 jjtc000 = false;
7401 } else {
7402 jjtree.popNode();
7403 }
7404 if (jjte000 instanceof RuntimeException) {
7405 {if (true) throw (RuntimeException)jjte000;}
7406 }
7407 if (jjte000 instanceof ParseException) {
7408 {if (true) throw (ParseException)jjte000;}
7409 }
7410 {if (true) throw (Error)jjte000;}
7411 } finally {
7412 if (jjtc000) {
7413 jjtree.closeNodeScope(jjtn000, true);
7414 }
7415 }
7416 throw new Error("Missing return statement in function");
7417 }
7418
7419 final public ASTDatatype Datatype() throws ParseException {
7420
7421 ASTDatatype jjtn000 = new ASTDatatype(this, JJTDATATYPE);
7422 boolean jjtc000 = true;
7423 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7424 StringBuilder sb = new StringBuilder();
7425 try {
7426 switch (jj_nt.kind) {
7427 case CC_IF:
7428
7429 simpleNode = CompilationDataType();
7430 sb.append(simpleNode.getImage());
7431 break;
7432 default:
7433 jj_la1[90] = jj_gen;
7434 if (jj_2_28(2)) {
7435 simpleNode = ScalarDataTypeName();
7436 sb.append(simpleNode.getImage());
7437 } else {
7438 switch (jj_nt.kind) {
7439 case REPLACE:
7440 case DEFINER:
7441 case CURRENT_USER:
7442 case LANGUAGE:
7443 case INLINE:
7444 case ADD:
7445 case AGGREGATE:
7446 case ARRAY:
7447 case AT:
7448 case ATTRIBUTE:
7449 case AUTHID:
7450 case BODY:
7451 case BULK:
7452 case BYTE:
7453 case CASCADE:
7454 case CLOSE:
7455 case COALESCE:
7456 case COLLECT:
7457 case COLUMN:
7458 case COMMENT:
7459 case COMMIT:
7460 case CONSTRUCTOR:
7461 case CONTINUE:
7462 case CONVERT:
7463 case CURRENT:
7464 case CURSOR:
7465 case DATA:
7466 case DAY:
7467 case DISABLE:
7468 case EDITIONABLE:
7469 case ELEMENT:
7470 case ENABLE:
7471 case ESCAPE:
7472 case EXCEPT:
7473 case EXCEPTIONS:
7474 case EXIT:
7475 case EXTERNAL:
7476 case EXTENDS:
7477 case EXTRACT:
7478 case FALSE:
7479 case FINAL:
7480 case FORCE:
7481 case FUNCTION:
7482 case GLOBAL:
7483 case HASH:
7484 case HEAP:
7485 case HOUR:
7486 case IMMEDIATE:
7487 case INDICES:
7488 case INDEXTYPE:
7489 case INDICATOR:
7490 case INSTANTIABLE:
7491 case INTERVAL:
7492 case INVALIDATE:
7493 case ISOLATION:
7494 case JAVA:
7495 case LEVEL:
7496 case LIMIT:
7497 case LOOP:
7498 case MAP:
7499 case MAX:
7500 case MEMBER:
7501 case MERGE:
7502 case MIN:
7503 case MINUTE:
7504 case MLSLABEL:
7505 case MODIFY:
7506 case MOD:
7507 case MONTH:
7508 case NATURAL:
7509 case NEW:
7510 case NO:
7511 case NONEDITIONABLE:
7512 case NULLIF:
7513 case OBJECT:
7514 case OID:
7515 case OPAQUE:
7516 case OPEN:
7517 case OPERATOR:
7518 case ORGANIZATION:
7519 case OTHERS:
7520 case OVERRIDING:
7521 case PACKAGE:
7522 case PARTITION:
7523 case PRESERVE:
7524 case PRIVATE:
7525 case PROCEDURE:
7526 case RANGE:
7527 case RAW:
7528 case REAL:
7529 case RECORD:
7530 case REF:
7531 case RELEASE:
7532 case RELIES_ON:
7533 case RENAME:
7534 case RESULT:
7535 case RETURN:
7536 case RETURNING:
7537 case REVERSE:
7538 case ROLLBACK:
7539 case ROW:
7540 case ROWS:
7541 case ROWID:
7542 case ROWNUM:
7543 case SAVE:
7544 case SAVEPOINT:
7545 case SECOND:
7546 case SELF:
7547 case SET:
7548 case SPACE:
7549 case SQL:
7550 case SQLCODE:
7551 case SQLERRM:
7552 case STATIC:
7553 case SUBTYPE:
7554 case SUBSTITUTABLE:
7555 case SUCCESSFUL:
7556 case SYSDATE:
7557 case SYS_REFCURSOR:
7558 case TEMPORARY:
7559 case TIME:
7560 case TIMESTAMP:
7561 case TIMEZONE_REGION:
7562 case TIMEZONE_ABBR:
7563 case TIMEZONE_MINUTE:
7564 case TIMEZONE_HOUR:
7565 case TRANSACTION:
7566 case TRUE:
7567 case TYPE:
7568 case UNDER:
7569 case USING:
7570 case YES:
7571 case SHOW:
7572 case A:
7573 case DOUBLE:
7574 case DEC:
7575 case PRECISION:
7576 case INT:
7577 case NUMERIC:
7578 case NCHAR:
7579 case NVARCHAR2:
7580 case STRING:
7581 case UROWID:
7582 case VARRAY:
7583 case VARYING:
7584 case BFILE:
7585 case BLOB:
7586 case CLOB:
7587 case NCLOB:
7588 case YEAR:
7589 case LOCAL:
7590 case ZONE:
7591 case CHARACTER:
7592 case AFTER:
7593 case BEFORE:
7594 case OLD:
7595 case PARENT:
7596 case ANALYZE:
7597 case ASSOCIATE:
7598 case AUDIT:
7599 case COMPOUND:
7600 case DATABASE:
7601 case CALL:
7602 case DDL:
7603 case DISASSOCIATE:
7604 case EACH:
7605 case FOLLOWS:
7606 case LOGOFF:
7607 case LOGON:
7608 case NESTED:
7609 case NOAUDIT:
7610 case SCHEMA:
7611 case SERVERERROR:
7612 case SHUTDOWN:
7613 case STARTUP:
7614 case STATEMENT:
7615 case STATISTICS:
7616 case SUSPEND:
7617 case TRUNCATE:
7618 case WRAPPED:
7619 case LIBRARY:
7620 case NAME:
7621 case STRUCT:
7622 case CONTEXT:
7623 case PARAMETERS:
7624 case LENGTH:
7625 case TDO:
7626 case MAXLEN:
7627 case CHARSETID:
7628 case CHARSETFORM:
7629 case ACCEPT:
7630 case ACCESSIBLE:
7631 case COPY:
7632 case DEFINE:
7633 case DISCONNECT:
7634 case HOST:
7635 case PRINT:
7636 case QUIT:
7637 case REMARK:
7638 case UNDEFINE:
7639 case VARIABLE:
7640 case WHENEVER:
7641 case ATTACH:
7642 case CAST:
7643 case TREAT:
7644 case TRIM:
7645 case LEFT:
7646 case RIGHT:
7647 case BOTH:
7648 case EMPTY:
7649 case MULTISET:
7650 case SUBMULTISET:
7651 case LEADING:
7652 case TRAILING:
7653 case CHAR_CS:
7654 case NCHAR_CS:
7655 case DBTIMEZONE:
7656 case SESSIONTIMEZONE:
7657 case AUTHENTICATED:
7658 case LINK:
7659 case SHARED:
7660 case DIRECTORY:
7661 case USER:
7662 case IDENTIFIER:
7663 case QUOTED_LITERAL:
7664 if (jj_2_27(2)) {
7665 jj_consume_token(REF);
7666 sb.append(token.image);
7667 } else {
7668 ;
7669 }
7670 simpleNode = QualifiedName();
7671 sb.append(simpleNode.getImage());
7672 switch (jj_nt.kind) {
7673 case 2:
7674 jj_consume_token(2);
7675 simpleNode = QualifiedName();
7676 sb.append("@"+simpleNode.getImage());
7677 break;
7678 default:
7679 jj_la1[87] = jj_gen;
7680 ;
7681 }
7682 switch (jj_nt.kind) {
7683 case 11:
7684 jj_consume_token(11);
7685 switch (jj_nt.kind) {
7686 case TYPE:
7687 jj_consume_token(TYPE);
7688 break;
7689 case ROWTYPE:
7690 jj_consume_token(ROWTYPE);
7691 break;
7692 default:
7693 jj_la1[88] = jj_gen;
7694 jj_consume_token(-1);
7695 throw new ParseException();
7696 }
7697 sb.append("%"+token.image);
7698 break;
7699 default:
7700 jj_la1[89] = jj_gen;
7701 ;
7702 }
7703 break;
7704 default:
7705 jj_la1[91] = jj_gen;
7706 jj_consume_token(-1);
7707 throw new ParseException();
7708 }
7709 }
7710 }
7711 jjtree.closeNodeScope(jjtn000, true);
7712 jjtc000 = false;
7713 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7714 } catch (Throwable jjte000) {
7715 if (jjtc000) {
7716 jjtree.clearNodeScope(jjtn000);
7717 jjtc000 = false;
7718 } else {
7719 jjtree.popNode();
7720 }
7721 if (jjte000 instanceof RuntimeException) {
7722 {if (true) throw (RuntimeException)jjte000;}
7723 }
7724 if (jjte000 instanceof ParseException) {
7725 {if (true) throw (ParseException)jjte000;}
7726 }
7727 {if (true) throw (Error)jjte000;}
7728 } finally {
7729 if (jjtc000) {
7730 jjtree.closeNodeScope(jjtn000, true);
7731 }
7732 }
7733 throw new Error("Missing return statement in function");
7734 }
7735
7736 final public ASTCompilationDataType CompilationDataType() throws ParseException {
7737
7738 ASTCompilationDataType jjtn000 = new ASTCompilationDataType(this, JJTCOMPILATIONDATATYPE);
7739 boolean jjtc000 = true;
7740 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
7741 StringBuilder sb = new StringBuilder() ;
7742 try {
7743 jj_consume_token(CC_IF);
7744 sb.append(" "); sb.append(token.image) ;
7745 simpleNode = ConditionalOrExpression();
7746 sb.append(" "); sb.append(simpleNode.getImage());
7747 jj_consume_token(CC_THEN);
7748 sb.append(" "); sb.append(token.image);
7749 simpleNode = Datatype();
7750 sb.append(" "); sb.append(simpleNode.getImage());
7751 label_18:
7752 while (true) {
7753 switch (jj_nt.kind) {
7754 case CC_ELSIF:
7755 ;
7756 break;
7757 default:
7758 jj_la1[92] = jj_gen;
7759 break label_18;
7760 }
7761 jj_consume_token(CC_ELSIF);
7762 sb.append(" "); sb.append(token.image);
7763 simpleNode = ConditionalOrExpression();
7764 sb.append(" "); sb.append(simpleNode.getImage());
7765 jj_consume_token(CC_THEN);
7766 sb.append(" "); sb.append(token.image);
7767 simpleNode = Datatype();
7768 sb.append(" "); sb.append(simpleNode.getImage());
7769 }
7770 label_19:
7771 while (true) {
7772 switch (jj_nt.kind) {
7773 case CC_ELSE:
7774 ;
7775 break;
7776 default:
7777 jj_la1[93] = jj_gen;
7778 break label_19;
7779 }
7780 jj_consume_token(CC_ELSE);
7781 sb.append(" "); sb.append(token.image);
7782 simpleNode = Datatype();
7783 sb.append(" "); sb.append(simpleNode.getImage());
7784 }
7785 jj_consume_token(CC_END);
7786 sb.append(" "); sb.append(token.image);
7787 jjtree.closeNodeScope(jjtn000, true);
7788 jjtc000 = false;
7789 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7790 } catch (Throwable jjte000) {
7791 if (jjtc000) {
7792 jjtree.clearNodeScope(jjtn000);
7793 jjtc000 = false;
7794 } else {
7795 jjtree.popNode();
7796 }
7797 if (jjte000 instanceof RuntimeException) {
7798 {if (true) throw (RuntimeException)jjte000;}
7799 }
7800 if (jjte000 instanceof ParseException) {
7801 {if (true) throw (ParseException)jjte000;}
7802 }
7803 {if (true) throw (Error)jjte000;}
7804 } finally {
7805 if (jjtc000) {
7806 jjtree.closeNodeScope(jjtn000, true);
7807 }
7808 }
7809 throw new Error("Missing return statement in function");
7810 }
7811
7812 final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
7813
7814 ASTCollectionTypeName jjtn000 = new ASTCollectionTypeName(this, JJTCOLLECTIONTYPENAME);
7815 boolean jjtc000 = true;
7816 jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null;
7817 StringBuilder sb = new StringBuilder();
7818 try {
7819 switch (jj_nt.kind) {
7820 case TABLE:
7821 jj_consume_token(TABLE);
7822 break;
7823 case VARRAY:
7824 jj_consume_token(VARRAY);
7825 break;
7826 case VARYING:
7827 jj_consume_token(VARYING);
7828 jj_consume_token(ARRAY);
7829 sb.append( "VARYING ARRAY") ;
7830 break;
7831 default:
7832 jj_la1[94] = jj_gen;
7833 jj_consume_token(-1);
7834 throw new ParseException();
7835 }
7836 if (sb.length() == 0) {
7837 sb.append(token.toString());
7838 }
7839 if (jj_2_29(2)) {
7840 jj_consume_token(5);
7841 size = NumericLiteral();
7842 sb.append( "(" + size);
7843 switch (jj_nt.kind) {
7844 case 6:
7845 jj_consume_token(6);
7846 precision = NumericLiteral();
7847 sb.append( "," + precision);
7848 break;
7849 default:
7850 jj_la1[95] = jj_gen;
7851 ;
7852 }
7853 switch (jj_nt.kind) {
7854 case CHAR:
7855 jj_consume_token(CHAR);
7856 sb.append( " CHAR") ;
7857 break;
7858 default:
7859 jj_la1[96] = jj_gen;
7860 ;
7861 }
7862 switch (jj_nt.kind) {
7863 case BYTE:
7864 jj_consume_token(BYTE);
7865 sb.append( " BYTE") ;
7866 break;
7867 default:
7868 jj_la1[97] = jj_gen;
7869 ;
7870 }
7871 jj_consume_token(7);
7872 sb.append( ")");
7873 } else {
7874 ;
7875 }
7876 jjtree.closeNodeScope(jjtn000, true);
7877 jjtc000 = false;
7878 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7879 } catch (Throwable jjte000) {
7880 if (jjtc000) {
7881 jjtree.clearNodeScope(jjtn000);
7882 jjtc000 = false;
7883 } else {
7884 jjtree.popNode();
7885 }
7886 if (jjte000 instanceof RuntimeException) {
7887 {if (true) throw (RuntimeException)jjte000;}
7888 }
7889 if (jjte000 instanceof ParseException) {
7890 {if (true) throw (ParseException)jjte000;}
7891 }
7892 {if (true) throw (Error)jjte000;}
7893 } finally {
7894 if (jjtc000) {
7895 jjtree.closeNodeScope(jjtn000, true);
7896 }
7897 }
7898 throw new Error("Missing return statement in function");
7899 }
7900
7901 final public ASTScalarDataTypeName ScalarDataTypeName() throws ParseException {
7902
7903 ASTScalarDataTypeName jjtn000 = new ASTScalarDataTypeName(this, JJTSCALARDATATYPENAME);
7904 boolean jjtc000 = true;
7905 jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null ;
7906 StringBuilder name = new StringBuilder();
7907 PLSQLNode characterSet = null;
7908 try {
7909 switch (jj_nt.kind) {
7910 case BFILE_BASE:
7911 jj_consume_token(BFILE_BASE);
7912 break;
7913 case BLOB_BASE:
7914 jj_consume_token(BLOB_BASE);
7915 break;
7916 case CHAR_BASE:
7917 jj_consume_token(CHAR_BASE);
7918 break;
7919 case CLOB_BASE:
7920 jj_consume_token(CLOB_BASE);
7921 break;
7922 case DATE_BASE:
7923 jj_consume_token(DATE_BASE);
7924 break;
7925 case NUMBER_BASE:
7926 jj_consume_token(NUMBER_BASE);
7927 break;
7928 case BINARY_INTEGER:
7929 jj_consume_token(BINARY_INTEGER);
7930 break;
7931 case DEC:
7932 jj_consume_token(DEC);
7933 break;
7934 case DECIMAL:
7935 jj_consume_token(DECIMAL);
7936 break;
7937 case DOUBLE:
7938 jj_consume_token(DOUBLE);
7939 jj_consume_token(PRECISION);
7940 name.append("DOUBLE PRECISION");
7941 break;
7942 case FLOAT:
7943 jj_consume_token(FLOAT);
7944 break;
7945 case INT:
7946 jj_consume_token(INT);
7947 break;
7948 case INTEGER:
7949 jj_consume_token(INTEGER);
7950 break;
7951 case NATURAL:
7952 jj_consume_token(NATURAL);
7953 break;
7954 case NATURALN:
7955 jj_consume_token(NATURALN);
7956 break;
7957 case NUMBER:
7958 jj_consume_token(NUMBER);
7959 break;
7960 case NUMERIC:
7961 jj_consume_token(NUMERIC);
7962 break;
7963 case PLS_INTEGER:
7964 jj_consume_token(PLS_INTEGER);
7965 break;
7966 case POSITIVE:
7967 jj_consume_token(POSITIVE);
7968 break;
7969 case POSITIVEN:
7970 jj_consume_token(POSITIVEN);
7971 break;
7972 case REAL:
7973 jj_consume_token(REAL);
7974 break;
7975 case SIGNTYPE:
7976 jj_consume_token(SIGNTYPE);
7977 break;
7978 case SMALLINT:
7979 jj_consume_token(SMALLINT);
7980 break;
7981 case CHAR:
7982 case LONG:
7983 case RAW:
7984 case ROWID:
7985 case VARCHAR:
7986 case VARCHAR2:
7987 case NCHAR:
7988 case NVARCHAR2:
7989 case STRING:
7990 case UROWID:
7991 case CLOB:
7992 case NCLOB:
7993 case CHARACTER:
7994 switch (jj_nt.kind) {
7995 case CHAR:
7996 jj_consume_token(CHAR);
7997 break;
7998 case CHARACTER:
7999 jj_consume_token(CHARACTER);
8000 break;
8001 default:
8002 jj_la1[98] = jj_gen;
8003 if (jj_2_30(2)) {
8004 jj_consume_token(LONG);
8005 jj_consume_token(RAW);
8006 name.append("LONG RAW");
8007 } else {
8008 switch (jj_nt.kind) {
8009 case LONG:
8010 jj_consume_token(LONG);
8011 break;
8012 case NCHAR:
8013 jj_consume_token(NCHAR);
8014 break;
8015 case NVARCHAR2:
8016 jj_consume_token(NVARCHAR2);
8017 break;
8018 case RAW:
8019 jj_consume_token(RAW);
8020 break;
8021 case ROWID:
8022 jj_consume_token(ROWID);
8023 break;
8024 case STRING:
8025 jj_consume_token(STRING);
8026 break;
8027 case UROWID:
8028 jj_consume_token(UROWID);
8029 break;
8030 case VARCHAR:
8031 jj_consume_token(VARCHAR);
8032 break;
8033 case VARCHAR2:
8034 jj_consume_token(VARCHAR2);
8035 break;
8036 case CLOB:
8037 jj_consume_token(CLOB);
8038 break;
8039 case NCLOB:
8040 jj_consume_token(NCLOB);
8041 break;
8042 default:
8043 jj_la1[99] = jj_gen;
8044 jj_consume_token(-1);
8045 throw new ParseException();
8046 }
8047 }
8048 }
8049 break;
8050 case BOOLEAN:
8051 jj_consume_token(BOOLEAN);
8052 break;
8053 case BFILE:
8054 jj_consume_token(BFILE);
8055 break;
8056 case BLOB:
8057 jj_consume_token(BLOB);
8058 break;
8059 case SYS_REFCURSOR:
8060 jj_consume_token(SYS_REFCURSOR);
8061 break;
8062 case REF:
8063 jj_consume_token(REF);
8064 jj_consume_token(CURSOR);
8065 name.append("REF CURSOR");
8066 break;
8067 case DATE:
8068 jj_consume_token(DATE);
8069 break;
8070 default:
8071 jj_la1[100] = jj_gen;
8072 if (jj_2_31(2)) {
8073 jj_consume_token(INTERVAL);
8074 jj_consume_token(YEAR);
8075 name.append("INTERVAL YEAR");
8076 } else if (jj_2_32(2)) {
8077 jj_consume_token(INTERVAL);
8078 jj_consume_token(DAY);
8079 name.append("INTERVAL DAY");
8080 } else {
8081 switch (jj_nt.kind) {
8082 case TIME:
8083 jj_consume_token(TIME);
8084 break;
8085 case TIMESTAMP:
8086 jj_consume_token(TIMESTAMP);
8087 break;
8088 case SELF:
8089 jj_consume_token(SELF);
8090 jj_consume_token(AS);
8091 jj_consume_token(RESULT);
8092 name.append("SELF AS RESULT");
8093 break;
8094 default:
8095 jj_la1[101] = jj_gen;
8096 jj_consume_token(-1);
8097 throw new ParseException();
8098 }
8099 }
8100 }
8101 if (name.length() == 0 ) {
8102 name.append(token.toString());
8103 }
8104 if (jj_2_33(2)) {
8105 jj_consume_token(5);
8106 size = NumericLiteral();
8107 name.append("("); name.append(size.getImage()) ;
8108 switch (jj_nt.kind) {
8109 case 6:
8110 jj_consume_token(6);
8111 precision = UnaryExpression(true);
8112 name.append(",") ; name.append(precision.getImage()) ;
8113 break;
8114 default:
8115 jj_la1[102] = jj_gen;
8116 ;
8117 }
8118 switch (jj_nt.kind) {
8119 case CHAR:
8120 jj_consume_token(CHAR);
8121 name.append(" CHAR") ;
8122 break;
8123 default:
8124 jj_la1[103] = jj_gen;
8125 ;
8126 }
8127 switch (jj_nt.kind) {
8128 case BYTE:
8129 jj_consume_token(BYTE);
8130 name.append(" BYTE") ;
8131 break;
8132 default:
8133 jj_la1[104] = jj_gen;
8134 ;
8135 }
8136 jj_consume_token(7);
8137 name.append( ")") ;
8138 } else {
8139 ;
8140 }
8141 switch (jj_nt.kind) {
8142 case TO:
8143 case WITH:
8144 case CHARACTER:
8145 switch (jj_nt.kind) {
8146 case CHARACTER:
8147 jj_consume_token(CHARACTER);
8148 jj_consume_token(SET);
8149 characterSet = Name();
8150 name.append( " CHARACTER SET ") ; name.append(characterSet.getImage()) ;
8151 break;
8152 default:
8153 jj_la1[105] = jj_gen;
8154 if (jj_2_35(4)) {
8155 jj_consume_token(WITH);
8156 jj_consume_token(LOCAL);
8157 jj_consume_token(TIME);
8158 jj_consume_token(ZONE);
8159 name.append(" WITH LOCAL TIME ZONE");
8160 } else if (jj_2_36(3)) {
8161 jj_consume_token(WITH);
8162 jj_consume_token(TIME);
8163 jj_consume_token(ZONE);
8164 name.append( " WITH TIME ZONE");
8165 } else if (jj_2_37(2)) {
8166 jj_consume_token(TO);
8167 jj_consume_token(MONTH);
8168 name.append( " TO MONTH");
8169 } else if (jj_2_38(2)) {
8170 jj_consume_token(TO);
8171 jj_consume_token(SECOND);
8172 name.append( " TO SECOND");
8173 if (jj_2_34(2)) {
8174 jj_consume_token(5);
8175 precision = NumericLiteral();
8176 name.append( "(" + precision) ;
8177 jj_consume_token(7);
8178 name.append( ")");
8179 } else {
8180 ;
8181 }
8182 } else {
8183 jj_consume_token(-1);
8184 throw new ParseException();
8185 }
8186 }
8187 break;
8188 default:
8189 jj_la1[106] = jj_gen;
8190 ;
8191 }
8192 jjtree.closeNodeScope(jjtn000, true);
8193 jjtc000 = false;
8194 jjtn000.setImage(name.toString()) ; {if (true) return jjtn000;}
8195 } catch (Throwable jjte000) {
8196 if (jjtc000) {
8197 jjtree.clearNodeScope(jjtn000);
8198 jjtc000 = false;
8199 } else {
8200 jjtree.popNode();
8201 }
8202 if (jjte000 instanceof RuntimeException) {
8203 {if (true) throw (RuntimeException)jjte000;}
8204 }
8205 if (jjte000 instanceof ParseException) {
8206 {if (true) throw (ParseException)jjte000;}
8207 }
8208 {if (true) throw (Error)jjte000;}
8209 } finally {
8210 if (jjtc000) {
8211 jjtree.closeNodeScope(jjtn000, true);
8212 }
8213 }
8214 throw new Error("Missing return statement in function");
8215 }
8216
8217 final public ASTDateTimeLiteral DateTimeLiteral() throws ParseException {
8218
8219 ASTDateTimeLiteral jjtn000 = new ASTDateTimeLiteral(this, JJTDATETIMELITERAL);
8220 boolean jjtc000 = true;
8221 jjtree.openNodeScope(jjtn000);Token t = null ;
8222 PLSQLNode simpleNode = null ;
8223 StringBuilder sb = new StringBuilder() ;
8224 try {
8225 switch (jj_nt.kind) {
8226 case INTERVAL:
8227 jj_consume_token(INTERVAL);
8228 break;
8229 case TIMESTAMP:
8230 jj_consume_token(TIMESTAMP);
8231 break;
8232 case DATE:
8233 jj_consume_token(DATE);
8234 break;
8235 default:
8236 jj_la1[107] = jj_gen;
8237 jj_consume_token(-1);
8238 throw new ParseException();
8239 }
8240 sb.append(token.image);
8241 switch (jj_nt.kind) {
8242 case CHARACTER_LITERAL:
8243 jj_consume_token(CHARACTER_LITERAL);
8244 sb.append(" "); sb.append(token.image);
8245 break;
8246 case STRING_LITERAL:
8247 simpleNode = StringLiteral();
8248 sb.append(" "); sb.append(simpleNode.getImage());
8249 break;
8250 default:
8251 jj_la1[108] = jj_gen;
8252 jj_consume_token(-1);
8253 throw new ParseException();
8254 }
8255 switch (jj_nt.kind) {
8256 case DAY:
8257 case HOUR:
8258 case MINUTE:
8259 case MONTH:
8260 case SECOND:
8261 case YEAR:
8262 switch (jj_nt.kind) {
8263 case YEAR:
8264 jj_consume_token(YEAR);
8265 break;
8266 case MONTH:
8267 jj_consume_token(MONTH);
8268 break;
8269 case DAY:
8270 jj_consume_token(DAY);
8271 break;
8272 case HOUR:
8273 jj_consume_token(HOUR);
8274 break;
8275 case MINUTE:
8276 jj_consume_token(MINUTE);
8277 break;
8278 case SECOND:
8279 jj_consume_token(SECOND);
8280 break;
8281 default:
8282 jj_la1[109] = jj_gen;
8283 jj_consume_token(-1);
8284 throw new ParseException();
8285 }
8286 break;
8287 default:
8288 jj_la1[110] = jj_gen;
8289 ;
8290 }
8291 if (null != t)
8292 {
8293 sb.append(" "); sb.append(token.image);
8294 t = null;
8295 }
8296 if (jj_2_39(2)) {
8297 jj_consume_token(5);
8298 simpleNode = NumericLiteral();
8299 sb.append("("); sb.append(simpleNode.getImage());
8300 jj_consume_token(7);
8301 sb.append("}");
8302 } else {
8303 ;
8304 }
8305 switch (jj_nt.kind) {
8306 case TO:
8307 case WITH:
8308 switch (jj_nt.kind) {
8309 case WITH:
8310 jj_consume_token(WITH);
8311 sb.append(" "); sb.append(token.toString()) ;
8312 switch (jj_nt.kind) {
8313 case LOCAL:
8314 jj_consume_token(LOCAL);
8315 sb.append(" "); sb.append(token.toString()) ;
8316 break;
8317 default:
8318 jj_la1[111] = jj_gen;
8319 ;
8320 }
8321 jj_consume_token(TIME);
8322 jj_consume_token(ZONE);
8323 sb.append(" "); sb.append("TIME ZONE") ;
8324 break;
8325 case TO:
8326 jj_consume_token(TO);
8327 sb.append(" "); sb.append(token.toString()) ;
8328 switch (jj_nt.kind) {
8329 case YEAR:
8330 jj_consume_token(YEAR);
8331 break;
8332 case MONTH:
8333 jj_consume_token(MONTH);
8334 break;
8335 case DAY:
8336 jj_consume_token(DAY);
8337 break;
8338 case HOUR:
8339 jj_consume_token(HOUR);
8340 break;
8341 case MINUTE:
8342 jj_consume_token(MINUTE);
8343 break;
8344 case SECOND:
8345 jj_consume_token(SECOND);
8346 break;
8347 default:
8348 jj_la1[112] = jj_gen;
8349 jj_consume_token(-1);
8350 throw new ParseException();
8351 }
8352 sb.append(token.image);
8353 if (jj_2_40(2)) {
8354 jj_consume_token(5);
8355 simpleNode = NumericLiteral();
8356 sb.append("("); sb.append(simpleNode.getImage());
8357 jj_consume_token(7);
8358 sb.append("}");
8359 } else {
8360 ;
8361 }
8362 break;
8363 default:
8364 jj_la1[113] = jj_gen;
8365 jj_consume_token(-1);
8366 throw new ParseException();
8367 }
8368 break;
8369 default:
8370 jj_la1[114] = jj_gen;
8371 ;
8372 }
8373 jjtree.closeNodeScope(jjtn000, true);
8374 jjtc000 = false;
8375 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
8376 } catch (Throwable jjte000) {
8377 if (jjtc000) {
8378 jjtree.clearNodeScope(jjtn000);
8379 jjtc000 = false;
8380 } else {
8381 jjtree.popNode();
8382 }
8383 if (jjte000 instanceof RuntimeException) {
8384 {if (true) throw (RuntimeException)jjte000;}
8385 }
8386 if (jjte000 instanceof ParseException) {
8387 {if (true) throw (ParseException)jjte000;}
8388 }
8389 {if (true) throw (Error)jjte000;}
8390 } finally {
8391 if (jjtc000) {
8392 jjtree.closeNodeScope(jjtn000, true);
8393 }
8394 }
8395 throw new Error("Missing return statement in function");
8396 }
8397
8398 final public ASTExceptionHandler ExceptionHandler() throws ParseException {
8399
8400 ASTExceptionHandler jjtn000 = new ASTExceptionHandler(this, JJTEXCEPTIONHANDLER);
8401 boolean jjtc000 = true;
8402 jjtree.openNodeScope(jjtn000);
8403 try {
8404 jj_consume_token(EXCEPTION);
8405 label_20:
8406 while (true) {
8407 if (jj_2_41(2)) {
8408 ;
8409 } else {
8410 break label_20;
8411 }
8412 jj_consume_token(WHEN);
8413 QualifiedName();
8414 label_21:
8415 while (true) {
8416 switch (jj_nt.kind) {
8417 case OR:
8418 ;
8419 break;
8420 default:
8421 jj_la1[115] = jj_gen;
8422 break label_21;
8423 }
8424 jj_consume_token(OR);
8425 QualifiedName();
8426 }
8427 jj_consume_token(THEN);
8428 label_22:
8429 while (true) {
8430 Statement();
8431 switch (jj_nt.kind) {
8432 case 5:
8433 case 16:
8434 case 17:
8435 case 21:
8436 case REPLACE:
8437 case DEFINER:
8438 case CURRENT_USER:
8439 case LANGUAGE:
8440 case INLINE:
8441 case ADD:
8442 case AGGREGATE:
8443 case ARRAY:
8444 case AT:
8445 case ATTRIBUTE:
8446 case AUTHID:
8447 case BEGIN:
8448 case BODY:
8449 case BULK:
8450 case BYTE:
8451 case CASCADE:
8452 case CASE:
8453 case CLOSE:
8454 case COALESCE:
8455 case COLLECT:
8456 case COLUMN:
8457 case COMMENT:
8458 case COMMIT:
8459 case CONSTRUCTOR:
8460 case CONTINUE:
8461 case CONVERT:
8462 case CURRENT:
8463 case CURSOR:
8464 case DATA:
8465 case DATE:
8466 case DAY:
8467 case DECLARE:
8468 case DELETE:
8469 case DISABLE:
8470 case EDITIONABLE:
8471 case ELEMENT:
8472 case ENABLE:
8473 case ESCAPE:
8474 case EXCEPT:
8475 case EXCEPTIONS:
8476 case EXECUTE:
8477 case EXIT:
8478 case EXTERNAL:
8479 case EXTENDS:
8480 case EXTRACT:
8481 case FALSE:
8482 case FETCH:
8483 case FINAL:
8484 case FOR:
8485 case FORALL:
8486 case FORCE:
8487 case FUNCTION:
8488 case GLOBAL:
8489 case GOTO:
8490 case HASH:
8491 case HEAP:
8492 case HOUR:
8493 case IF:
8494 case IMMEDIATE:
8495 case INDICES:
8496 case INDEXTYPE:
8497 case INDICATOR:
8498 case INSERT:
8499 case INSTANTIABLE:
8500 case INTERVAL:
8501 case INVALIDATE:
8502 case ISOLATION:
8503 case JAVA:
8504 case LEVEL:
8505 case LIMIT:
8506 case LOCK:
8507 case LOOP:
8508 case MAP:
8509 case MAX:
8510 case MEMBER:
8511 case MERGE:
8512 case MIN:
8513 case MINUTE:
8514 case MLSLABEL:
8515 case MODIFY:
8516 case MOD:
8517 case MONTH:
8518 case NATURAL:
8519 case NEW:
8520 case NEW_DOT:
8521 case NO:
8522 case NONEDITIONABLE:
8523 case NOT:
8524 case NULL:
8525 case NULLIF:
8526 case OBJECT:
8527 case OID:
8528 case OPAQUE:
8529 case OPEN:
8530 case OPERATOR:
8531 case ORGANIZATION:
8532 case OTHERS:
8533 case OVERRIDING:
8534 case PACKAGE:
8535 case PARTITION:
8536 case PIPE:
8537 case PRAGMA:
8538 case PRESERVE:
8539 case PRIVATE:
8540 case PROCEDURE:
8541 case RAISE:
8542 case RANGE:
8543 case RAW:
8544 case REAL:
8545 case RECORD:
8546 case REF:
8547 case RELEASE:
8548 case RELIES_ON:
8549 case RENAME:
8550 case RESULT:
8551 case RETURN:
8552 case RETURNING:
8553 case REVERSE:
8554 case ROLLBACK:
8555 case ROW:
8556 case ROWS:
8557 case ROWID:
8558 case ROWNUM:
8559 case SAVE:
8560 case SAVEPOINT:
8561 case SECOND:
8562 case SELECT:
8563 case SELF:
8564 case SET:
8565 case SPACE:
8566 case SQL:
8567 case SQLCODE:
8568 case SQLERRM:
8569 case STATIC:
8570 case SUBTYPE:
8571 case SUBSTITUTABLE:
8572 case SUCCESSFUL:
8573 case SYSDATE:
8574 case SYS_REFCURSOR:
8575 case TEMPORARY:
8576 case TIME:
8577 case TIMESTAMP:
8578 case TIMEZONE_REGION:
8579 case TIMEZONE_ABBR:
8580 case TIMEZONE_MINUTE:
8581 case TIMEZONE_HOUR:
8582 case TRANSACTION:
8583 case TRUE:
8584 case TYPE:
8585 case UNDER:
8586 case USING:
8587 case WHILE:
8588 case YES:
8589 case SHOW:
8590 case A:
8591 case UPDATE:
8592 case DOUBLE:
8593 case DEC:
8594 case PRECISION:
8595 case INT:
8596 case NUMERIC:
8597 case NCHAR:
8598 case NVARCHAR2:
8599 case STRING:
8600 case UROWID:
8601 case VARRAY:
8602 case VARYING:
8603 case BFILE:
8604 case BLOB:
8605 case CLOB:
8606 case NCLOB:
8607 case YEAR:
8608 case LOCAL:
8609 case WITH:
8610 case ZONE:
8611 case CHARACTER:
8612 case AFTER:
8613 case BEFORE:
8614 case OLD:
8615 case PARENT:
8616 case CC_IF:
8617 case CC_ERROR:
8618 case ANALYZE:
8619 case ASSOCIATE:
8620 case AUDIT:
8621 case COMPOUND:
8622 case DATABASE:
8623 case CALL:
8624 case DDL:
8625 case DISASSOCIATE:
8626 case EACH:
8627 case FOLLOWS:
8628 case LOGOFF:
8629 case LOGON:
8630 case NESTED:
8631 case NOAUDIT:
8632 case SCHEMA:
8633 case SERVERERROR:
8634 case SHUTDOWN:
8635 case STARTUP:
8636 case STATEMENT:
8637 case STATISTICS:
8638 case SUSPEND:
8639 case TRUNCATE:
8640 case WRAPPED:
8641 case LIBRARY:
8642 case NAME:
8643 case STRUCT:
8644 case CONTEXT:
8645 case PARAMETERS:
8646 case LENGTH:
8647 case TDO:
8648 case MAXLEN:
8649 case CHARSETID:
8650 case CHARSETFORM:
8651 case ACCEPT:
8652 case ACCESSIBLE:
8653 case COPY:
8654 case DEFINE:
8655 case DISCONNECT:
8656 case HOST:
8657 case PRINT:
8658 case QUIT:
8659 case REMARK:
8660 case UNDEFINE:
8661 case VARIABLE:
8662 case WHENEVER:
8663 case ATTACH:
8664 case CAST:
8665 case TREAT:
8666 case TRIM:
8667 case LEFT:
8668 case RIGHT:
8669 case BOTH:
8670 case EMPTY:
8671 case MULTISET:
8672 case SUBMULTISET:
8673 case LEADING:
8674 case TRAILING:
8675 case CHAR_CS:
8676 case NCHAR_CS:
8677 case DBTIMEZONE:
8678 case SESSIONTIMEZONE:
8679 case AUTHENTICATED:
8680 case LINK:
8681 case SHARED:
8682 case DIRECTORY:
8683 case USER:
8684 case IDENTIFIER:
8685 case UNSIGNED_NUMERIC_LITERAL:
8686 case CHARACTER_LITERAL:
8687 case STRING_LITERAL:
8688 case QUOTED_LITERAL:
8689 ;
8690 break;
8691 default:
8692 jj_la1[116] = jj_gen;
8693 break label_22;
8694 }
8695 }
8696 }
8697 switch (jj_nt.kind) {
8698 case WHEN:
8699 jj_consume_token(WHEN);
8700 jj_consume_token(OTHERS);
8701 jj_consume_token(THEN);
8702 label_23:
8703 while (true) {
8704 Statement();
8705 switch (jj_nt.kind) {
8706 case 5:
8707 case 16:
8708 case 17:
8709 case 21:
8710 case REPLACE:
8711 case DEFINER:
8712 case CURRENT_USER:
8713 case LANGUAGE:
8714 case INLINE:
8715 case ADD:
8716 case AGGREGATE:
8717 case ARRAY:
8718 case AT:
8719 case ATTRIBUTE:
8720 case AUTHID:
8721 case BEGIN:
8722 case BODY:
8723 case BULK:
8724 case BYTE:
8725 case CASCADE:
8726 case CASE:
8727 case CLOSE:
8728 case COALESCE:
8729 case COLLECT:
8730 case COLUMN:
8731 case COMMENT:
8732 case COMMIT:
8733 case CONSTRUCTOR:
8734 case CONTINUE:
8735 case CONVERT:
8736 case CURRENT:
8737 case CURSOR:
8738 case DATA:
8739 case DATE:
8740 case DAY:
8741 case DECLARE:
8742 case DELETE:
8743 case DISABLE:
8744 case EDITIONABLE:
8745 case ELEMENT:
8746 case ENABLE:
8747 case ESCAPE:
8748 case EXCEPT:
8749 case EXCEPTIONS:
8750 case EXECUTE:
8751 case EXIT:
8752 case EXTERNAL:
8753 case EXTENDS:
8754 case EXTRACT:
8755 case FALSE:
8756 case FETCH:
8757 case FINAL:
8758 case FOR:
8759 case FORALL:
8760 case FORCE:
8761 case FUNCTION:
8762 case GLOBAL:
8763 case GOTO:
8764 case HASH:
8765 case HEAP:
8766 case HOUR:
8767 case IF:
8768 case IMMEDIATE:
8769 case INDICES:
8770 case INDEXTYPE:
8771 case INDICATOR:
8772 case INSERT:
8773 case INSTANTIABLE:
8774 case INTERVAL:
8775 case INVALIDATE:
8776 case ISOLATION:
8777 case JAVA:
8778 case LEVEL:
8779 case LIMIT:
8780 case LOCK:
8781 case LOOP:
8782 case MAP:
8783 case MAX:
8784 case MEMBER:
8785 case MERGE:
8786 case MIN:
8787 case MINUTE:
8788 case MLSLABEL:
8789 case MODIFY:
8790 case MOD:
8791 case MONTH:
8792 case NATURAL:
8793 case NEW:
8794 case NEW_DOT:
8795 case NO:
8796 case NONEDITIONABLE:
8797 case NOT:
8798 case NULL:
8799 case NULLIF:
8800 case OBJECT:
8801 case OID:
8802 case OPAQUE:
8803 case OPEN:
8804 case OPERATOR:
8805 case ORGANIZATION:
8806 case OTHERS:
8807 case OVERRIDING:
8808 case PACKAGE:
8809 case PARTITION:
8810 case PIPE:
8811 case PRAGMA:
8812 case PRESERVE:
8813 case PRIVATE:
8814 case PROCEDURE:
8815 case RAISE:
8816 case RANGE:
8817 case RAW:
8818 case REAL:
8819 case RECORD:
8820 case REF:
8821 case RELEASE:
8822 case RELIES_ON:
8823 case RENAME:
8824 case RESULT:
8825 case RETURN:
8826 case RETURNING:
8827 case REVERSE:
8828 case ROLLBACK:
8829 case ROW:
8830 case ROWS:
8831 case ROWID:
8832 case ROWNUM:
8833 case SAVE:
8834 case SAVEPOINT:
8835 case SECOND:
8836 case SELECT:
8837 case SELF:
8838 case SET:
8839 case SPACE:
8840 case SQL:
8841 case SQLCODE:
8842 case SQLERRM:
8843 case STATIC:
8844 case SUBTYPE:
8845 case SUBSTITUTABLE:
8846 case SUCCESSFUL:
8847 case SYSDATE:
8848 case SYS_REFCURSOR:
8849 case TEMPORARY:
8850 case TIME:
8851 case TIMESTAMP:
8852 case TIMEZONE_REGION:
8853 case TIMEZONE_ABBR:
8854 case TIMEZONE_MINUTE:
8855 case TIMEZONE_HOUR:
8856 case TRANSACTION:
8857 case TRUE:
8858 case TYPE:
8859 case UNDER:
8860 case USING:
8861 case WHILE:
8862 case YES:
8863 case SHOW:
8864 case A:
8865 case UPDATE:
8866 case DOUBLE:
8867 case DEC:
8868 case PRECISION:
8869 case INT:
8870 case NUMERIC:
8871 case NCHAR:
8872 case NVARCHAR2:
8873 case STRING:
8874 case UROWID:
8875 case VARRAY:
8876 case VARYING:
8877 case BFILE:
8878 case BLOB:
8879 case CLOB:
8880 case NCLOB:
8881 case YEAR:
8882 case LOCAL:
8883 case WITH:
8884 case ZONE:
8885 case CHARACTER:
8886 case AFTER:
8887 case BEFORE:
8888 case OLD:
8889 case PARENT:
8890 case CC_IF:
8891 case CC_ERROR:
8892 case ANALYZE:
8893 case ASSOCIATE:
8894 case AUDIT:
8895 case COMPOUND:
8896 case DATABASE:
8897 case CALL:
8898 case DDL:
8899 case DISASSOCIATE:
8900 case EACH:
8901 case FOLLOWS:
8902 case LOGOFF:
8903 case LOGON:
8904 case NESTED:
8905 case NOAUDIT:
8906 case SCHEMA:
8907 case SERVERERROR:
8908 case SHUTDOWN:
8909 case STARTUP:
8910 case STATEMENT:
8911 case STATISTICS:
8912 case SUSPEND:
8913 case TRUNCATE:
8914 case WRAPPED:
8915 case LIBRARY:
8916 case NAME:
8917 case STRUCT:
8918 case CONTEXT:
8919 case PARAMETERS:
8920 case LENGTH:
8921 case TDO:
8922 case MAXLEN:
8923 case CHARSETID:
8924 case CHARSETFORM:
8925 case ACCEPT:
8926 case ACCESSIBLE:
8927 case COPY:
8928 case DEFINE:
8929 case DISCONNECT:
8930 case HOST:
8931 case PRINT:
8932 case QUIT:
8933 case REMARK:
8934 case UNDEFINE:
8935 case VARIABLE:
8936 case WHENEVER:
8937 case ATTACH:
8938 case CAST:
8939 case TREAT:
8940 case TRIM:
8941 case LEFT:
8942 case RIGHT:
8943 case BOTH:
8944 case EMPTY:
8945 case MULTISET:
8946 case SUBMULTISET:
8947 case LEADING:
8948 case TRAILING:
8949 case CHAR_CS:
8950 case NCHAR_CS:
8951 case DBTIMEZONE:
8952 case SESSIONTIMEZONE:
8953 case AUTHENTICATED:
8954 case LINK:
8955 case SHARED:
8956 case DIRECTORY:
8957 case USER:
8958 case IDENTIFIER:
8959 case UNSIGNED_NUMERIC_LITERAL:
8960 case CHARACTER_LITERAL:
8961 case STRING_LITERAL:
8962 case QUOTED_LITERAL:
8963 ;
8964 break;
8965 default:
8966 jj_la1[117] = jj_gen;
8967 break label_23;
8968 }
8969 }
8970 break;
8971 default:
8972 jj_la1[118] = jj_gen;
8973 ;
8974 }
8975 jjtree.closeNodeScope(jjtn000, true);
8976 jjtc000 = false;
8977 {if (true) return jjtn000 ;}
8978 } catch (Throwable jjte000) {
8979 if (jjtc000) {
8980 jjtree.clearNodeScope(jjtn000);
8981 jjtc000 = false;
8982 } else {
8983 jjtree.popNode();
8984 }
8985 if (jjte000 instanceof RuntimeException) {
8986 {if (true) throw (RuntimeException)jjte000;}
8987 }
8988 if (jjte000 instanceof ParseException) {
8989 {if (true) throw (ParseException)jjte000;}
8990 }
8991 {if (true) throw (Error)jjte000;}
8992 } finally {
8993 if (jjtc000) {
8994 jjtree.closeNodeScope(jjtn000, true);
8995 }
8996 }
8997 throw new Error("Missing return statement in function");
8998 }
8999
9000 final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
9001
9002 ASTSkip2NextTerminator jjtn000 = new ASTSkip2NextTerminator(this, JJTSKIP2NEXTTERMINATOR);
9003 boolean jjtc000 = true;
9004 jjtree.openNodeScope(jjtn000);Token beginToken = getToken(0);
9005 Token t = getToken(1);
9006 int count = (initiator == null) ? 0 : 1;
9007 if(t.image.equals(initiator)) count++;
9008 while (count > 0 || !t.image.equals(terminator))
9009 {
9010 t = getNextToken();
9011 t = getToken(1);
9012 if(t.image.equals(initiator)) count++;
9013 if(t.image.equals(terminator)) count--;
9014 if((null != t.specialToken && beginToken.kind != SELECT && beginToken.kind != INSERT && beginToken.kind != UPDATE && beginToken.kind != DELETE && beginToken.kind != MERGE) || t.kind == EOF)
9015 return;
9016 if (t.specialToken != null && "/".equals(t.image))
9017 return;
9018 }
9019 try {
9020 jjtree.closeNodeScope(jjtn000, true);
9021 jjtc000 = false;
9022 {if (true) return;}
9023 } finally {
9024 if (jjtc000) {
9025 jjtree.closeNodeScope(jjtn000, true);
9026 }
9027 }
9028 }
9029
9030
9031
9032
9033 final public void Skip2NextOccurrence(String target) throws ParseException {
9034
9035 ASTSkip2NextOccurrence jjtn000 = new ASTSkip2NextOccurrence(this, JJTSKIP2NEXTOCCURRENCE);
9036 boolean jjtc000 = true;
9037 jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9038 while (!nextToken.image.equals(target)
9039 && (null == nextToken.specialToken || !nextToken.specialToken.image.equals(target) )
9040 && nextToken.kind!=EOF
9041 )
9042 {
9043 nextToken = getNextToken();
9044 nextToken = getToken(1);
9045 }
9046 try {
9047 jjtree.closeNodeScope(jjtn000, true);
9048 jjtc000 = false;
9049 {if (true) return;}
9050 } finally {
9051 if (jjtc000) {
9052 jjtree.closeNodeScope(jjtn000, true);
9053 }
9054 }
9055 }
9056
9057
9058
9059
9060 final public void SkipPastNextOccurrence(String target) throws ParseException {
9061
9062 ASTSkipPastNextOccurrence jjtn000 = new ASTSkipPastNextOccurrence(this, JJTSKIPPASTNEXTOCCURRENCE);
9063 boolean jjtc000 = true;
9064 jjtree.openNodeScope(jjtn000);Token t = null;
9065 Skip2NextOccurrence(target) ;
9066 t = getNextToken();
9067 try {
9068 jjtree.closeNodeScope(jjtn000, true);
9069 jjtc000 = false;
9070 {if (true) return;}
9071 } finally {
9072 if (jjtc000) {
9073 jjtree.closeNodeScope(jjtn000, true);
9074 }
9075 }
9076 }
9077
9078
9079
9080
9081 final public void Skip2NextTokenOccurrence(int target) throws ParseException {
9082
9083 ASTSkip2NextTokenOccurrence jjtn000 = new ASTSkip2NextTokenOccurrence(this, JJTSKIP2NEXTTOKENOCCURRENCE);
9084 boolean jjtc000 = true;
9085 jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9086 Token specToken = null ;
9087 while (nextToken.kind!=target
9088 && (null == nextToken.specialToken || nextToken.specialToken.kind!=target )
9089 && nextToken.kind!=EOF
9090 )
9091 {
9092
9093
9094
9095
9096
9097
9098
9099
9100
9101
9102
9103
9104
9105
9106 specToken = nextToken.specialToken;
9107 if (null!= specToken)
9108 {
9109
9110 while (specToken != null && specToken.kind != target)
9111 {
9112 specToken = specToken.specialToken;
9113 }
9114
9115
9116 if (null != specToken && specToken.kind == target)
9117 {
9118 break;
9119 }
9120 }
9121
9122 nextToken = getNextToken();
9123 nextToken = getToken(1);
9124 }
9125 try {
9126 jjtree.closeNodeScope(jjtn000, true);
9127 jjtc000 = false;
9128 {if (true) return;}
9129 } finally {
9130 if (jjtc000) {
9131 jjtree.closeNodeScope(jjtn000, true);
9132 }
9133 }
9134 }
9135
9136
9137
9138
9139 final public void SkipPastNextTokenOccurrence(int target) throws ParseException {
9140
9141 ASTSkipPastNextTokenOccurrence jjtn000 = new ASTSkipPastNextTokenOccurrence(this, JJTSKIPPASTNEXTTOKENOCCURRENCE);
9142 boolean jjtc000 = true;
9143 jjtree.openNodeScope(jjtn000);Token t = null;
9144 Skip2NextTokenOccurrence(target) ;
9145 t = getNextToken();
9146 try {
9147 jjtree.closeNodeScope(jjtn000, true);
9148 jjtc000 = false;
9149 {if (true) return;}
9150 } finally {
9151 if (jjtc000) {
9152 jjtree.closeNodeScope(jjtn000, true);
9153 }
9154 }
9155 }
9156
9157
9158
9159
9160 final public ASTRead2NextOccurrence Read2NextOccurrence(String target) throws ParseException {
9161
9162 ASTRead2NextOccurrence jjtn000 = new ASTRead2NextOccurrence(this, JJTREAD2NEXTOCCURRENCE);
9163 boolean jjtc000 = true;
9164 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9165 Token nextToken = getToken(1);
9166 while (!nextToken.image.equals(target)
9167 && nextToken.kind!=EOF
9168 )
9169 {
9170 nextToken = getNextToken();
9171 sb.append(nextToken.image);
9172 nextToken = getToken(1);
9173 }
9174 try {
9175 jjtree.closeNodeScope(jjtn000, true);
9176 jjtc000 = false;
9177 jjtn000.setImage(sb.toString()) ; jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9178 } finally {
9179 if (jjtc000) {
9180 jjtree.closeNodeScope(jjtn000, true);
9181 }
9182 }
9183 throw new Error("Missing return statement in function");
9184 }
9185
9186
9187
9188
9189 final public ASTReadPastNextOccurrence ReadPastNextOccurrence(String target) throws ParseException {
9190
9191 ASTReadPastNextOccurrence jjtn000 = new ASTReadPastNextOccurrence(this, JJTREADPASTNEXTOCCURRENCE);
9192 boolean jjtc000 = true;
9193 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9194 Token t = null;
9195 sb.append(Read2NextOccurrence(target)) ;
9196 t = getNextToken();
9197 sb.append(t.image);
9198 try {
9199 jjtree.closeNodeScope(jjtn000, true);
9200 jjtc000 = false;
9201 jjtn000.setImage(sb.toString()) ; jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9202 } finally {
9203 if (jjtc000) {
9204 jjtree.closeNodeScope(jjtn000, true);
9205 }
9206 }
9207 throw new Error("Missing return statement in function");
9208 }
9209
9210
9211
9212
9213 final public ASTSqlStatement SqlStatement(String initiator, String terminator) throws ParseException {
9214
9215 ASTSqlStatement jjtn000 = new ASTSqlStatement(this, JJTSQLSTATEMENT);
9216 boolean jjtc000 = true;
9217 jjtree.openNodeScope(jjtn000);
9218 try {
9219 switch (jj_nt.kind) {
9220 case SELECT:
9221 jj_consume_token(SELECT);
9222 break;
9223 case UPDATE:
9224 jj_consume_token(UPDATE);
9225 break;
9226 case INSERT:
9227 jj_consume_token(INSERT);
9228 break;
9229 case DELETE:
9230 jj_consume_token(DELETE);
9231 break;
9232 case COMMIT:
9233 jj_consume_token(COMMIT);
9234 break;
9235 case ROLLBACK:
9236 jj_consume_token(ROLLBACK);
9237 break;
9238 case SAVEPOINT:
9239 jj_consume_token(SAVEPOINT);
9240 break;
9241 case EXECUTE:
9242 jj_consume_token(EXECUTE);
9243 break;
9244 case SET:
9245 jj_consume_token(SET);
9246 jj_consume_token(TRANSACTION);
9247 break;
9248 case LOCK:
9249 jj_consume_token(LOCK);
9250 jj_consume_token(TABLE);
9251 break;
9252 case MERGE:
9253 jj_consume_token(MERGE);
9254 break;
9255 case WITH:
9256 jj_consume_token(WITH);
9257 break;
9258 default:
9259 jj_la1[119] = jj_gen;
9260 jj_consume_token(-1);
9261 throw new ParseException();
9262 }
9263 Skip2NextTerminator(initiator,terminator);
9264 jjtree.closeNodeScope(jjtn000, true);
9265 jjtc000 = false;
9266 {if (true) return jjtn000 ;}
9267 } catch (Throwable jjte000) {
9268 if (jjtc000) {
9269 jjtree.clearNodeScope(jjtn000);
9270 jjtc000 = false;
9271 } else {
9272 jjtree.popNode();
9273 }
9274 if (jjte000 instanceof RuntimeException) {
9275 {if (true) throw (RuntimeException)jjte000;}
9276 }
9277 if (jjte000 instanceof ParseException) {
9278 {if (true) throw (ParseException)jjte000;}
9279 }
9280 {if (true) throw (Error)jjte000;}
9281 } finally {
9282 if (jjtc000) {
9283 jjtree.closeNodeScope(jjtn000, true);
9284 }
9285 }
9286 throw new Error("Missing return statement in function");
9287 }
9288
9289
9290
9291
9292
9293
9294
9295
9296
9297
9298
9299
9300
9301
9302
9303
9304
9305
9306
9307
9308
9309
9310
9311
9312
9313
9314
9315
9316
9317
9318
9319
9320
9321
9322
9323
9324
9325
9326
9327
9328 final public void WrappedObject() throws ParseException {
9329
9330 ASTWrappedObject jjtn000 = new ASTWrappedObject(this, JJTWRAPPEDOBJECT);
9331 boolean jjtc000 = true;
9332 jjtree.openNodeScope(jjtn000);
9333 try {
9334 jj_consume_token(WRAPPED);
9335 jjtree.closeNodeScope(jjtn000, true);
9336 jjtc000 = false;
9337 Token nextToken;
9338
9339 nextToken = getToken(1);
9340 while (
9341 null != nextToken && nextToken.kind!=EOF
9342 )
9343 {
9344 nextToken = getNextToken();
9345
9346
9347 nextToken = getToken(1);
9348 }
9349 {if (true) return;}
9350 } finally {
9351 if (jjtc000) {
9352 jjtree.closeNodeScope(jjtn000, true);
9353 }
9354 }
9355 }
9356
9357
9358
9359
9360
9361
9362
9363
9364 final public ASTUnlabelledStatement UnlabelledStatement() throws ParseException {
9365
9366 ASTUnlabelledStatement jjtn000 = new ASTUnlabelledStatement(this, JJTUNLABELLEDSTATEMENT);
9367 boolean jjtc000 = true;
9368 jjtree.openNodeScope(jjtn000);
9369 try {
9370 if (jj_2_42(2147483647)) {
9371 SqlStatement(null,";");
9372 switch (jj_nt.kind) {
9373 case 4:
9374 jj_consume_token(4);
9375 break;
9376 default:
9377 jj_la1[120] = jj_gen;
9378 ;
9379 }
9380 } else if (jj_2_43(3)) {
9381 ContinueStatement();
9382 jj_consume_token(4);
9383 } else {
9384 switch (jj_nt.kind) {
9385 case CASE:
9386 CaseStatement();
9387 jj_consume_token(4);
9388 break;
9389 case IF:
9390 IfStatement();
9391 jj_consume_token(4);
9392 break;
9393 case FOR:
9394 ForStatement();
9395 jj_consume_token(4);
9396 break;
9397 case FORALL:
9398 ForAllStatement();
9399 jj_consume_token(4);
9400 break;
9401 case LOOP:
9402 LoopStatement();
9403 jj_consume_token(4);
9404 break;
9405 case WHILE:
9406 WhileStatement();
9407 jj_consume_token(4);
9408 break;
9409 case GOTO:
9410 GotoStatement();
9411 jj_consume_token(4);
9412 break;
9413 case RETURN:
9414 ReturnStatement();
9415 jj_consume_token(4);
9416 break;
9417 case EXIT:
9418 ExitStatement();
9419 jj_consume_token(4);
9420 break;
9421 case RAISE:
9422 RaiseStatement();
9423 jj_consume_token(4);
9424 break;
9425 case CLOSE:
9426 CloseStatement();
9427 jj_consume_token(4);
9428 break;
9429 case OPEN:
9430 OpenStatement();
9431 jj_consume_token(4);
9432 break;
9433 case FETCH:
9434 FetchStatement();
9435 jj_consume_token(4);
9436 break;
9437 case BEGIN:
9438 case DECLARE:
9439 Block();
9440 jj_consume_token(4);
9441 break;
9442 case EXECUTE:
9443 EmbeddedSqlStatement();
9444 jj_consume_token(4);
9445 break;
9446 case PIPE:
9447 PipelineStatement();
9448 jj_consume_token(4);
9449 break;
9450 case CC_IF:
9451 case CC_ERROR:
9452 ConditionalCompilationStatement();
9453 break;
9454 case PRAGMA:
9455 InlinePragma();
9456 jj_consume_token(4);
9457 break;
9458 case 5:
9459 case 16:
9460 case 17:
9461 case REPLACE:
9462 case DEFINER:
9463 case CURRENT_USER:
9464 case LANGUAGE:
9465 case INLINE:
9466 case ADD:
9467 case AGGREGATE:
9468 case ARRAY:
9469 case AT:
9470 case ATTRIBUTE:
9471 case AUTHID:
9472 case BODY:
9473 case BULK:
9474 case BYTE:
9475 case CASCADE:
9476 case COALESCE:
9477 case COLLECT:
9478 case COLUMN:
9479 case COMMENT:
9480 case COMMIT:
9481 case CONSTRUCTOR:
9482 case CONTINUE:
9483 case CONVERT:
9484 case CURRENT:
9485 case CURSOR:
9486 case DATA:
9487 case DATE:
9488 case DAY:
9489 case DISABLE:
9490 case EDITIONABLE:
9491 case ELEMENT:
9492 case ENABLE:
9493 case ESCAPE:
9494 case EXCEPT:
9495 case EXCEPTIONS:
9496 case EXTERNAL:
9497 case EXTENDS:
9498 case EXTRACT:
9499 case FALSE:
9500 case FINAL:
9501 case FORCE:
9502 case FUNCTION:
9503 case GLOBAL:
9504 case HASH:
9505 case HEAP:
9506 case HOUR:
9507 case IMMEDIATE:
9508 case INDICES:
9509 case INDEXTYPE:
9510 case INDICATOR:
9511 case INSTANTIABLE:
9512 case INTERVAL:
9513 case INVALIDATE:
9514 case ISOLATION:
9515 case JAVA:
9516 case LEVEL:
9517 case LIMIT:
9518 case MAP:
9519 case MAX:
9520 case MEMBER:
9521 case MERGE:
9522 case MIN:
9523 case MINUTE:
9524 case MLSLABEL:
9525 case MODIFY:
9526 case MOD:
9527 case MONTH:
9528 case NATURAL:
9529 case NEW:
9530 case NEW_DOT:
9531 case NO:
9532 case NONEDITIONABLE:
9533 case NOT:
9534 case NULL:
9535 case NULLIF:
9536 case OBJECT:
9537 case OID:
9538 case OPAQUE:
9539 case OPERATOR:
9540 case ORGANIZATION:
9541 case OTHERS:
9542 case OVERRIDING:
9543 case PACKAGE:
9544 case PARTITION:
9545 case PRESERVE:
9546 case PRIVATE:
9547 case PROCEDURE:
9548 case RANGE:
9549 case RAW:
9550 case REAL:
9551 case RECORD:
9552 case REF:
9553 case RELEASE:
9554 case RELIES_ON:
9555 case RENAME:
9556 case RESULT:
9557 case RETURNING:
9558 case REVERSE:
9559 case ROLLBACK:
9560 case ROW:
9561 case ROWS:
9562 case ROWID:
9563 case ROWNUM:
9564 case SAVE:
9565 case SAVEPOINT:
9566 case SECOND:
9567 case SELECT:
9568 case SELF:
9569 case SET:
9570 case SPACE:
9571 case SQL:
9572 case SQLCODE:
9573 case SQLERRM:
9574 case STATIC:
9575 case SUBTYPE:
9576 case SUBSTITUTABLE:
9577 case SUCCESSFUL:
9578 case SYSDATE:
9579 case SYS_REFCURSOR:
9580 case TEMPORARY:
9581 case TIME:
9582 case TIMESTAMP:
9583 case TIMEZONE_REGION:
9584 case TIMEZONE_ABBR:
9585 case TIMEZONE_MINUTE:
9586 case TIMEZONE_HOUR:
9587 case TRANSACTION:
9588 case TRUE:
9589 case TYPE:
9590 case UNDER:
9591 case USING:
9592 case YES:
9593 case SHOW:
9594 case A:
9595 case DOUBLE:
9596 case DEC:
9597 case PRECISION:
9598 case INT:
9599 case NUMERIC:
9600 case NCHAR:
9601 case NVARCHAR2:
9602 case STRING:
9603 case UROWID:
9604 case VARRAY:
9605 case VARYING:
9606 case BFILE:
9607 case BLOB:
9608 case CLOB:
9609 case NCLOB:
9610 case YEAR:
9611 case LOCAL:
9612 case WITH:
9613 case ZONE:
9614 case CHARACTER:
9615 case AFTER:
9616 case BEFORE:
9617 case OLD:
9618 case PARENT:
9619 case ANALYZE:
9620 case ASSOCIATE:
9621 case AUDIT:
9622 case COMPOUND:
9623 case DATABASE:
9624 case CALL:
9625 case DDL:
9626 case DISASSOCIATE:
9627 case EACH:
9628 case FOLLOWS:
9629 case LOGOFF:
9630 case LOGON:
9631 case NESTED:
9632 case NOAUDIT:
9633 case SCHEMA:
9634 case SERVERERROR:
9635 case SHUTDOWN:
9636 case STARTUP:
9637 case STATEMENT:
9638 case STATISTICS:
9639 case SUSPEND:
9640 case TRUNCATE:
9641 case WRAPPED:
9642 case LIBRARY:
9643 case NAME:
9644 case STRUCT:
9645 case CONTEXT:
9646 case PARAMETERS:
9647 case LENGTH:
9648 case TDO:
9649 case MAXLEN:
9650 case CHARSETID:
9651 case CHARSETFORM:
9652 case ACCEPT:
9653 case ACCESSIBLE:
9654 case COPY:
9655 case DEFINE:
9656 case DISCONNECT:
9657 case HOST:
9658 case PRINT:
9659 case QUIT:
9660 case REMARK:
9661 case UNDEFINE:
9662 case VARIABLE:
9663 case WHENEVER:
9664 case ATTACH:
9665 case CAST:
9666 case TREAT:
9667 case TRIM:
9668 case LEFT:
9669 case RIGHT:
9670 case BOTH:
9671 case EMPTY:
9672 case MULTISET:
9673 case SUBMULTISET:
9674 case LEADING:
9675 case TRAILING:
9676 case CHAR_CS:
9677 case NCHAR_CS:
9678 case DBTIMEZONE:
9679 case SESSIONTIMEZONE:
9680 case AUTHENTICATED:
9681 case LINK:
9682 case SHARED:
9683 case DIRECTORY:
9684 case USER:
9685 case IDENTIFIER:
9686 case UNSIGNED_NUMERIC_LITERAL:
9687 case CHARACTER_LITERAL:
9688 case STRING_LITERAL:
9689 case QUOTED_LITERAL:
9690 Expression();
9691 jj_consume_token(4);
9692 break;
9693 default:
9694 jj_la1[121] = jj_gen;
9695 jj_consume_token(-1);
9696 throw new ParseException();
9697 }
9698 }
9699 jjtree.closeNodeScope(jjtn000, true);
9700 jjtc000 = false;
9701 {if (true) return jjtn000 ;}
9702 } catch (Throwable jjte000) {
9703 if (jjtc000) {
9704 jjtree.clearNodeScope(jjtn000);
9705 jjtc000 = false;
9706 } else {
9707 jjtree.popNode();
9708 }
9709 if (jjte000 instanceof RuntimeException) {
9710 {if (true) throw (RuntimeException)jjte000;}
9711 }
9712 if (jjte000 instanceof ParseException) {
9713 {if (true) throw (ParseException)jjte000;}
9714 }
9715 {if (true) throw (Error)jjte000;}
9716 } finally {
9717 if (jjtc000) {
9718 jjtree.closeNodeScope(jjtn000, true);
9719 }
9720 }
9721 throw new Error("Missing return statement in function");
9722 }
9723
9724 final public ASTStatement Statement() throws ParseException {
9725
9726 ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
9727 boolean jjtc000 = true;
9728 jjtree.openNodeScope(jjtn000);
9729 try {
9730 switch (jj_nt.kind) {
9731 case 21:
9732 LabelledStatement();
9733 break;
9734 case 5:
9735 case 16:
9736 case 17:
9737 case REPLACE:
9738 case DEFINER:
9739 case CURRENT_USER:
9740 case LANGUAGE:
9741 case INLINE:
9742 case ADD:
9743 case AGGREGATE:
9744 case ARRAY:
9745 case AT:
9746 case ATTRIBUTE:
9747 case AUTHID:
9748 case BEGIN:
9749 case BODY:
9750 case BULK:
9751 case BYTE:
9752 case CASCADE:
9753 case CASE:
9754 case CLOSE:
9755 case COALESCE:
9756 case COLLECT:
9757 case COLUMN:
9758 case COMMENT:
9759 case COMMIT:
9760 case CONSTRUCTOR:
9761 case CONTINUE:
9762 case CONVERT:
9763 case CURRENT:
9764 case CURSOR:
9765 case DATA:
9766 case DATE:
9767 case DAY:
9768 case DECLARE:
9769 case DELETE:
9770 case DISABLE:
9771 case EDITIONABLE:
9772 case ELEMENT:
9773 case ENABLE:
9774 case ESCAPE:
9775 case EXCEPT:
9776 case EXCEPTIONS:
9777 case EXECUTE:
9778 case EXIT:
9779 case EXTERNAL:
9780 case EXTENDS:
9781 case EXTRACT:
9782 case FALSE:
9783 case FETCH:
9784 case FINAL:
9785 case FOR:
9786 case FORALL:
9787 case FORCE:
9788 case FUNCTION:
9789 case GLOBAL:
9790 case GOTO:
9791 case HASH:
9792 case HEAP:
9793 case HOUR:
9794 case IF:
9795 case IMMEDIATE:
9796 case INDICES:
9797 case INDEXTYPE:
9798 case INDICATOR:
9799 case INSERT:
9800 case INSTANTIABLE:
9801 case INTERVAL:
9802 case INVALIDATE:
9803 case ISOLATION:
9804 case JAVA:
9805 case LEVEL:
9806 case LIMIT:
9807 case LOCK:
9808 case LOOP:
9809 case MAP:
9810 case MAX:
9811 case MEMBER:
9812 case MERGE:
9813 case MIN:
9814 case MINUTE:
9815 case MLSLABEL:
9816 case MODIFY:
9817 case MOD:
9818 case MONTH:
9819 case NATURAL:
9820 case NEW:
9821 case NEW_DOT:
9822 case NO:
9823 case NONEDITIONABLE:
9824 case NOT:
9825 case NULL:
9826 case NULLIF:
9827 case OBJECT:
9828 case OID:
9829 case OPAQUE:
9830 case OPEN:
9831 case OPERATOR:
9832 case ORGANIZATION:
9833 case OTHERS:
9834 case OVERRIDING:
9835 case PACKAGE:
9836 case PARTITION:
9837 case PIPE:
9838 case PRAGMA:
9839 case PRESERVE:
9840 case PRIVATE:
9841 case PROCEDURE:
9842 case RAISE:
9843 case RANGE:
9844 case RAW:
9845 case REAL:
9846 case RECORD:
9847 case REF:
9848 case RELEASE:
9849 case RELIES_ON:
9850 case RENAME:
9851 case RESULT:
9852 case RETURN:
9853 case RETURNING:
9854 case REVERSE:
9855 case ROLLBACK:
9856 case ROW:
9857 case ROWS:
9858 case ROWID:
9859 case ROWNUM:
9860 case SAVE:
9861 case SAVEPOINT:
9862 case SECOND:
9863 case SELECT:
9864 case SELF:
9865 case SET:
9866 case SPACE:
9867 case SQL:
9868 case SQLCODE:
9869 case SQLERRM:
9870 case STATIC:
9871 case SUBTYPE:
9872 case SUBSTITUTABLE:
9873 case SUCCESSFUL:
9874 case SYSDATE:
9875 case SYS_REFCURSOR:
9876 case TEMPORARY:
9877 case TIME:
9878 case TIMESTAMP:
9879 case TIMEZONE_REGION:
9880 case TIMEZONE_ABBR:
9881 case TIMEZONE_MINUTE:
9882 case TIMEZONE_HOUR:
9883 case TRANSACTION:
9884 case TRUE:
9885 case TYPE:
9886 case UNDER:
9887 case USING:
9888 case WHILE:
9889 case YES:
9890 case SHOW:
9891 case A:
9892 case UPDATE:
9893 case DOUBLE:
9894 case DEC:
9895 case PRECISION:
9896 case INT:
9897 case NUMERIC:
9898 case NCHAR:
9899 case NVARCHAR2:
9900 case STRING:
9901 case UROWID:
9902 case VARRAY:
9903 case VARYING:
9904 case BFILE:
9905 case BLOB:
9906 case CLOB:
9907 case NCLOB:
9908 case YEAR:
9909 case LOCAL:
9910 case WITH:
9911 case ZONE:
9912 case CHARACTER:
9913 case AFTER:
9914 case BEFORE:
9915 case OLD:
9916 case PARENT:
9917 case CC_IF:
9918 case CC_ERROR:
9919 case ANALYZE:
9920 case ASSOCIATE:
9921 case AUDIT:
9922 case COMPOUND:
9923 case DATABASE:
9924 case CALL:
9925 case DDL:
9926 case DISASSOCIATE:
9927 case EACH:
9928 case FOLLOWS:
9929 case LOGOFF:
9930 case LOGON:
9931 case NESTED:
9932 case NOAUDIT:
9933 case SCHEMA:
9934 case SERVERERROR:
9935 case SHUTDOWN:
9936 case STARTUP:
9937 case STATEMENT:
9938 case STATISTICS:
9939 case SUSPEND:
9940 case TRUNCATE:
9941 case WRAPPED:
9942 case LIBRARY:
9943 case NAME:
9944 case STRUCT:
9945 case CONTEXT:
9946 case PARAMETERS:
9947 case LENGTH:
9948 case TDO:
9949 case MAXLEN:
9950 case CHARSETID:
9951 case CHARSETFORM:
9952 case ACCEPT:
9953 case ACCESSIBLE:
9954 case COPY:
9955 case DEFINE:
9956 case DISCONNECT:
9957 case HOST:
9958 case PRINT:
9959 case QUIT:
9960 case REMARK:
9961 case UNDEFINE:
9962 case VARIABLE:
9963 case WHENEVER:
9964 case ATTACH:
9965 case CAST:
9966 case TREAT:
9967 case TRIM:
9968 case LEFT:
9969 case RIGHT:
9970 case BOTH:
9971 case EMPTY:
9972 case MULTISET:
9973 case SUBMULTISET:
9974 case LEADING:
9975 case TRAILING:
9976 case CHAR_CS:
9977 case NCHAR_CS:
9978 case DBTIMEZONE:
9979 case SESSIONTIMEZONE:
9980 case AUTHENTICATED:
9981 case LINK:
9982 case SHARED:
9983 case DIRECTORY:
9984 case USER:
9985 case IDENTIFIER:
9986 case UNSIGNED_NUMERIC_LITERAL:
9987 case CHARACTER_LITERAL:
9988 case STRING_LITERAL:
9989 case QUOTED_LITERAL:
9990 UnlabelledStatement();
9991 break;
9992 default:
9993 jj_la1[122] = jj_gen;
9994 jj_consume_token(-1);
9995 throw new ParseException();
9996 }
9997 jjtree.closeNodeScope(jjtn000, true);
9998 jjtc000 = false;
9999 {if (true) return jjtn000 ;}
10000 } catch (Throwable jjte000) {
10001 if (jjtc000) {
10002 jjtree.clearNodeScope(jjtn000);
10003 jjtc000 = false;
10004 } else {
10005 jjtree.popNode();
10006 }
10007 if (jjte000 instanceof RuntimeException) {
10008 {if (true) throw (RuntimeException)jjte000;}
10009 }
10010 if (jjte000 instanceof ParseException) {
10011 {if (true) throw (ParseException)jjte000;}
10012 }
10013 {if (true) throw (Error)jjte000;}
10014 } finally {
10015 if (jjtc000) {
10016 jjtree.closeNodeScope(jjtn000, true);
10017 }
10018 }
10019 throw new Error("Missing return statement in function");
10020 }
10021
10022
10023
10024
10025
10026 final public ASTLabelledStatement LabelledStatement() throws ParseException {
10027
10028 ASTLabelledStatement jjtn000 = new ASTLabelledStatement(this, JJTLABELLEDSTATEMENT);
10029 boolean jjtc000 = true;
10030 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
10031 try {
10032 label_24:
10033 while (true) {
10034 simpleNode = Label();
10035 switch (jj_nt.kind) {
10036 case 21:
10037 ;
10038 break;
10039 default:
10040 jj_la1[123] = jj_gen;
10041 break label_24;
10042 }
10043 }
10044 UnlabelledStatement();
10045 jjtree.closeNodeScope(jjtn000, true);
10046 jjtc000 = false;
10047 jjtn000.setImage( simpleNode.getImage() ) ;
10048 {if (true) return jjtn000 ;}
10049 } catch (Throwable jjte000) {
10050 if (jjtc000) {
10051 jjtree.clearNodeScope(jjtn000);
10052 jjtc000 = false;
10053 } else {
10054 jjtree.popNode();
10055 }
10056 if (jjte000 instanceof RuntimeException) {
10057 {if (true) throw (RuntimeException)jjte000;}
10058 }
10059 if (jjte000 instanceof ParseException) {
10060 {if (true) throw (ParseException)jjte000;}
10061 }
10062 {if (true) throw (Error)jjte000;}
10063 } finally {
10064 if (jjtc000) {
10065 jjtree.closeNodeScope(jjtn000, true);
10066 }
10067 }
10068 throw new Error("Missing return statement in function");
10069 }
10070
10071 final public ASTCaseStatement CaseStatement() throws ParseException {
10072
10073 ASTCaseStatement jjtn000 = new ASTCaseStatement(this, JJTCASESTATEMENT);
10074 boolean jjtc000 = true;
10075 jjtree.openNodeScope(jjtn000);
10076 try {
10077 jj_consume_token(CASE);
10078 switch (jj_nt.kind) {
10079 case 5:
10080 case 16:
10081 case 17:
10082 case REPLACE:
10083 case DEFINER:
10084 case CURRENT_USER:
10085 case LANGUAGE:
10086 case INLINE:
10087 case ADD:
10088 case AGGREGATE:
10089 case ARRAY:
10090 case AT:
10091 case ATTRIBUTE:
10092 case AUTHID:
10093 case BODY:
10094 case BULK:
10095 case BYTE:
10096 case CASCADE:
10097 case CASE:
10098 case CLOSE:
10099 case COALESCE:
10100 case COLLECT:
10101 case COLUMN:
10102 case COMMENT:
10103 case COMMIT:
10104 case CONSTRUCTOR:
10105 case CONTINUE:
10106 case CONVERT:
10107 case CURRENT:
10108 case CURSOR:
10109 case DATA:
10110 case DATE:
10111 case DAY:
10112 case DISABLE:
10113 case EDITIONABLE:
10114 case ELEMENT:
10115 case ENABLE:
10116 case ESCAPE:
10117 case EXCEPT:
10118 case EXCEPTIONS:
10119 case EXIT:
10120 case EXTERNAL:
10121 case EXTENDS:
10122 case EXTRACT:
10123 case FALSE:
10124 case FINAL:
10125 case FORCE:
10126 case FUNCTION:
10127 case GLOBAL:
10128 case HASH:
10129 case HEAP:
10130 case HOUR:
10131 case IMMEDIATE:
10132 case INDICES:
10133 case INDEXTYPE:
10134 case INDICATOR:
10135 case INSTANTIABLE:
10136 case INTERVAL:
10137 case INVALIDATE:
10138 case ISOLATION:
10139 case JAVA:
10140 case LEVEL:
10141 case LIMIT:
10142 case LOOP:
10143 case MAP:
10144 case MAX:
10145 case MEMBER:
10146 case MERGE:
10147 case MIN:
10148 case MINUTE:
10149 case MLSLABEL:
10150 case MODIFY:
10151 case MOD:
10152 case MONTH:
10153 case NATURAL:
10154 case NEW:
10155 case NEW_DOT:
10156 case NO:
10157 case NONEDITIONABLE:
10158 case NOT:
10159 case NULL:
10160 case NULLIF:
10161 case OBJECT:
10162 case OID:
10163 case OPAQUE:
10164 case OPEN:
10165 case OPERATOR:
10166 case ORGANIZATION:
10167 case OTHERS:
10168 case OVERRIDING:
10169 case PACKAGE:
10170 case PARTITION:
10171 case PRESERVE:
10172 case PRIVATE:
10173 case PROCEDURE:
10174 case RANGE:
10175 case RAW:
10176 case REAL:
10177 case RECORD:
10178 case REF:
10179 case RELEASE:
10180 case RELIES_ON:
10181 case RENAME:
10182 case RESULT:
10183 case RETURN:
10184 case RETURNING:
10185 case REVERSE:
10186 case ROLLBACK:
10187 case ROW:
10188 case ROWS:
10189 case ROWID:
10190 case ROWNUM:
10191 case SAVE:
10192 case SAVEPOINT:
10193 case SECOND:
10194 case SELECT:
10195 case SELF:
10196 case SET:
10197 case SPACE:
10198 case SQL:
10199 case SQLCODE:
10200 case SQLERRM:
10201 case STATIC:
10202 case SUBTYPE:
10203 case SUBSTITUTABLE:
10204 case SUCCESSFUL:
10205 case SYSDATE:
10206 case SYS_REFCURSOR:
10207 case TEMPORARY:
10208 case TIME:
10209 case TIMESTAMP:
10210 case TIMEZONE_REGION:
10211 case TIMEZONE_ABBR:
10212 case TIMEZONE_MINUTE:
10213 case TIMEZONE_HOUR:
10214 case TRANSACTION:
10215 case TRUE:
10216 case TYPE:
10217 case UNDER:
10218 case USING:
10219 case YES:
10220 case SHOW:
10221 case A:
10222 case DOUBLE:
10223 case DEC:
10224 case PRECISION:
10225 case INT:
10226 case NUMERIC:
10227 case NCHAR:
10228 case NVARCHAR2:
10229 case STRING:
10230 case UROWID:
10231 case VARRAY:
10232 case VARYING:
10233 case BFILE:
10234 case BLOB:
10235 case CLOB:
10236 case NCLOB:
10237 case YEAR:
10238 case LOCAL:
10239 case WITH:
10240 case ZONE:
10241 case CHARACTER:
10242 case AFTER:
10243 case BEFORE:
10244 case OLD:
10245 case PARENT:
10246 case CC_IF:
10247 case ANALYZE:
10248 case ASSOCIATE:
10249 case AUDIT:
10250 case COMPOUND:
10251 case DATABASE:
10252 case CALL:
10253 case DDL:
10254 case DISASSOCIATE:
10255 case EACH:
10256 case FOLLOWS:
10257 case LOGOFF:
10258 case LOGON:
10259 case NESTED:
10260 case NOAUDIT:
10261 case SCHEMA:
10262 case SERVERERROR:
10263 case SHUTDOWN:
10264 case STARTUP:
10265 case STATEMENT:
10266 case STATISTICS:
10267 case SUSPEND:
10268 case TRUNCATE:
10269 case WRAPPED:
10270 case LIBRARY:
10271 case NAME:
10272 case STRUCT:
10273 case CONTEXT:
10274 case PARAMETERS:
10275 case LENGTH:
10276 case TDO:
10277 case MAXLEN:
10278 case CHARSETID:
10279 case CHARSETFORM:
10280 case ACCEPT:
10281 case ACCESSIBLE:
10282 case COPY:
10283 case DEFINE:
10284 case DISCONNECT:
10285 case HOST:
10286 case PRINT:
10287 case QUIT:
10288 case REMARK:
10289 case UNDEFINE:
10290 case VARIABLE:
10291 case WHENEVER:
10292 case ATTACH:
10293 case CAST:
10294 case TREAT:
10295 case TRIM:
10296 case LEFT:
10297 case RIGHT:
10298 case BOTH:
10299 case EMPTY:
10300 case MULTISET:
10301 case SUBMULTISET:
10302 case LEADING:
10303 case TRAILING:
10304 case CHAR_CS:
10305 case NCHAR_CS:
10306 case DBTIMEZONE:
10307 case SESSIONTIMEZONE:
10308 case AUTHENTICATED:
10309 case LINK:
10310 case SHARED:
10311 case DIRECTORY:
10312 case USER:
10313 case IDENTIFIER:
10314 case UNSIGNED_NUMERIC_LITERAL:
10315 case CHARACTER_LITERAL:
10316 case STRING_LITERAL:
10317 case QUOTED_LITERAL:
10318 Expression();
10319 break;
10320 default:
10321 jj_la1[124] = jj_gen;
10322 ;
10323 }
10324 label_25:
10325 while (true) {
10326 switch (jj_nt.kind) {
10327 case WHEN:
10328 ;
10329 break;
10330 default:
10331 jj_la1[125] = jj_gen;
10332 break label_25;
10333 }
10334 CaseWhenClause();
10335 }
10336 switch (jj_nt.kind) {
10337 case ELSE:
10338 ElseClause();
10339 break;
10340 default:
10341 jj_la1[126] = jj_gen;
10342 ;
10343 }
10344 jj_consume_token(END);
10345 jj_consume_token(CASE);
10346 switch (jj_nt.kind) {
10347 case IDENTIFIER:
10348 jj_consume_token(IDENTIFIER);
10349 break;
10350 default:
10351 jj_la1[127] = jj_gen;
10352 ;
10353 }
10354 jjtree.closeNodeScope(jjtn000, true);
10355 jjtc000 = false;
10356 {if (true) return jjtn000 ;}
10357 } catch (Throwable jjte000) {
10358 if (jjtc000) {
10359 jjtree.clearNodeScope(jjtn000);
10360 jjtc000 = false;
10361 } else {
10362 jjtree.popNode();
10363 }
10364 if (jjte000 instanceof RuntimeException) {
10365 {if (true) throw (RuntimeException)jjte000;}
10366 }
10367 if (jjte000 instanceof ParseException) {
10368 {if (true) throw (ParseException)jjte000;}
10369 }
10370 {if (true) throw (Error)jjte000;}
10371 } finally {
10372 if (jjtc000) {
10373 jjtree.closeNodeScope(jjtn000, true);
10374 }
10375 }
10376 throw new Error("Missing return statement in function");
10377 }
10378
10379 final public ASTCaseWhenClause CaseWhenClause() throws ParseException {
10380
10381 ASTCaseWhenClause jjtn000 = new ASTCaseWhenClause(this, JJTCASEWHENCLAUSE);
10382 boolean jjtc000 = true;
10383 jjtree.openNodeScope(jjtn000);
10384 try {
10385 jj_consume_token(WHEN);
10386 Expression();
10387 jj_consume_token(THEN);
10388 label_26:
10389 while (true) {
10390 Statement();
10391 switch (jj_nt.kind) {
10392 case 5:
10393 case 16:
10394 case 17:
10395 case 21:
10396 case REPLACE:
10397 case DEFINER:
10398 case CURRENT_USER:
10399 case LANGUAGE:
10400 case INLINE:
10401 case ADD:
10402 case AGGREGATE:
10403 case ARRAY:
10404 case AT:
10405 case ATTRIBUTE:
10406 case AUTHID:
10407 case BEGIN:
10408 case BODY:
10409 case BULK:
10410 case BYTE:
10411 case CASCADE:
10412 case CASE:
10413 case CLOSE:
10414 case COALESCE:
10415 case COLLECT:
10416 case COLUMN:
10417 case COMMENT:
10418 case COMMIT:
10419 case CONSTRUCTOR:
10420 case CONTINUE:
10421 case CONVERT:
10422 case CURRENT:
10423 case CURSOR:
10424 case DATA:
10425 case DATE:
10426 case DAY:
10427 case DECLARE:
10428 case DELETE:
10429 case DISABLE:
10430 case EDITIONABLE:
10431 case ELEMENT:
10432 case ENABLE:
10433 case ESCAPE:
10434 case EXCEPT:
10435 case EXCEPTIONS:
10436 case EXECUTE:
10437 case EXIT:
10438 case EXTERNAL:
10439 case EXTENDS:
10440 case EXTRACT:
10441 case FALSE:
10442 case FETCH:
10443 case FINAL:
10444 case FOR:
10445 case FORALL:
10446 case FORCE:
10447 case FUNCTION:
10448 case GLOBAL:
10449 case GOTO:
10450 case HASH:
10451 case HEAP:
10452 case HOUR:
10453 case IF:
10454 case IMMEDIATE:
10455 case INDICES:
10456 case INDEXTYPE:
10457 case INDICATOR:
10458 case INSERT:
10459 case INSTANTIABLE:
10460 case INTERVAL:
10461 case INVALIDATE:
10462 case ISOLATION:
10463 case JAVA:
10464 case LEVEL:
10465 case LIMIT:
10466 case LOCK:
10467 case LOOP:
10468 case MAP:
10469 case MAX:
10470 case MEMBER:
10471 case MERGE:
10472 case MIN:
10473 case MINUTE:
10474 case MLSLABEL:
10475 case MODIFY:
10476 case MOD:
10477 case MONTH:
10478 case NATURAL:
10479 case NEW:
10480 case NEW_DOT:
10481 case NO:
10482 case NONEDITIONABLE:
10483 case NOT:
10484 case NULL:
10485 case NULLIF:
10486 case OBJECT:
10487 case OID:
10488 case OPAQUE:
10489 case OPEN:
10490 case OPERATOR:
10491 case ORGANIZATION:
10492 case OTHERS:
10493 case OVERRIDING:
10494 case PACKAGE:
10495 case PARTITION:
10496 case PIPE:
10497 case PRAGMA:
10498 case PRESERVE:
10499 case PRIVATE:
10500 case PROCEDURE:
10501 case RAISE:
10502 case RANGE:
10503 case RAW:
10504 case REAL:
10505 case RECORD:
10506 case REF:
10507 case RELEASE:
10508 case RELIES_ON:
10509 case RENAME:
10510 case RESULT:
10511 case RETURN:
10512 case RETURNING:
10513 case REVERSE:
10514 case ROLLBACK:
10515 case ROW:
10516 case ROWS:
10517 case ROWID:
10518 case ROWNUM:
10519 case SAVE:
10520 case SAVEPOINT:
10521 case SECOND:
10522 case SELECT:
10523 case SELF:
10524 case SET:
10525 case SPACE:
10526 case SQL:
10527 case SQLCODE:
10528 case SQLERRM:
10529 case STATIC:
10530 case SUBTYPE:
10531 case SUBSTITUTABLE:
10532 case SUCCESSFUL:
10533 case SYSDATE:
10534 case SYS_REFCURSOR:
10535 case TEMPORARY:
10536 case TIME:
10537 case TIMESTAMP:
10538 case TIMEZONE_REGION:
10539 case TIMEZONE_ABBR:
10540 case TIMEZONE_MINUTE:
10541 case TIMEZONE_HOUR:
10542 case TRANSACTION:
10543 case TRUE:
10544 case TYPE:
10545 case UNDER:
10546 case USING:
10547 case WHILE:
10548 case YES:
10549 case SHOW:
10550 case A:
10551 case UPDATE:
10552 case DOUBLE:
10553 case DEC:
10554 case PRECISION:
10555 case INT:
10556 case NUMERIC:
10557 case NCHAR:
10558 case NVARCHAR2:
10559 case STRING:
10560 case UROWID:
10561 case VARRAY:
10562 case VARYING:
10563 case BFILE:
10564 case BLOB:
10565 case CLOB:
10566 case NCLOB:
10567 case YEAR:
10568 case LOCAL:
10569 case WITH:
10570 case ZONE:
10571 case CHARACTER:
10572 case AFTER:
10573 case BEFORE:
10574 case OLD:
10575 case PARENT:
10576 case CC_IF:
10577 case CC_ERROR:
10578 case ANALYZE:
10579 case ASSOCIATE:
10580 case AUDIT:
10581 case COMPOUND:
10582 case DATABASE:
10583 case CALL:
10584 case DDL:
10585 case DISASSOCIATE:
10586 case EACH:
10587 case FOLLOWS:
10588 case LOGOFF:
10589 case LOGON:
10590 case NESTED:
10591 case NOAUDIT:
10592 case SCHEMA:
10593 case SERVERERROR:
10594 case SHUTDOWN:
10595 case STARTUP:
10596 case STATEMENT:
10597 case STATISTICS:
10598 case SUSPEND:
10599 case TRUNCATE:
10600 case WRAPPED:
10601 case LIBRARY:
10602 case NAME:
10603 case STRUCT:
10604 case CONTEXT:
10605 case PARAMETERS:
10606 case LENGTH:
10607 case TDO:
10608 case MAXLEN:
10609 case CHARSETID:
10610 case CHARSETFORM:
10611 case ACCEPT:
10612 case ACCESSIBLE:
10613 case COPY:
10614 case DEFINE:
10615 case DISCONNECT:
10616 case HOST:
10617 case PRINT:
10618 case QUIT:
10619 case REMARK:
10620 case UNDEFINE:
10621 case VARIABLE:
10622 case WHENEVER:
10623 case ATTACH:
10624 case CAST:
10625 case TREAT:
10626 case TRIM:
10627 case LEFT:
10628 case RIGHT:
10629 case BOTH:
10630 case EMPTY:
10631 case MULTISET:
10632 case SUBMULTISET:
10633 case LEADING:
10634 case TRAILING:
10635 case CHAR_CS:
10636 case NCHAR_CS:
10637 case DBTIMEZONE:
10638 case SESSIONTIMEZONE:
10639 case AUTHENTICATED:
10640 case LINK:
10641 case SHARED:
10642 case DIRECTORY:
10643 case USER:
10644 case IDENTIFIER:
10645 case UNSIGNED_NUMERIC_LITERAL:
10646 case CHARACTER_LITERAL:
10647 case STRING_LITERAL:
10648 case QUOTED_LITERAL:
10649 ;
10650 break;
10651 default:
10652 jj_la1[128] = jj_gen;
10653 break label_26;
10654 }
10655 }
10656 jjtree.closeNodeScope(jjtn000, true);
10657 jjtc000 = false;
10658 {if (true) return jjtn000 ;}
10659 } catch (Throwable jjte000) {
10660 if (jjtc000) {
10661 jjtree.clearNodeScope(jjtn000);
10662 jjtc000 = false;
10663 } else {
10664 jjtree.popNode();
10665 }
10666 if (jjte000 instanceof RuntimeException) {
10667 {if (true) throw (RuntimeException)jjte000;}
10668 }
10669 if (jjte000 instanceof ParseException) {
10670 {if (true) throw (ParseException)jjte000;}
10671 }
10672 {if (true) throw (Error)jjte000;}
10673 } finally {
10674 if (jjtc000) {
10675 jjtree.closeNodeScope(jjtn000, true);
10676 }
10677 }
10678 throw new Error("Missing return statement in function");
10679 }
10680
10681 final public ASTElseClause ElseClause() throws ParseException {
10682
10683 ASTElseClause jjtn000 = new ASTElseClause(this, JJTELSECLAUSE);
10684 boolean jjtc000 = true;
10685 jjtree.openNodeScope(jjtn000);
10686 try {
10687 jj_consume_token(ELSE);
10688 label_27:
10689 while (true) {
10690 Statement();
10691 switch (jj_nt.kind) {
10692 case 5:
10693 case 16:
10694 case 17:
10695 case 21:
10696 case REPLACE:
10697 case DEFINER:
10698 case CURRENT_USER:
10699 case LANGUAGE:
10700 case INLINE:
10701 case ADD:
10702 case AGGREGATE:
10703 case ARRAY:
10704 case AT:
10705 case ATTRIBUTE:
10706 case AUTHID:
10707 case BEGIN:
10708 case BODY:
10709 case BULK:
10710 case BYTE:
10711 case CASCADE:
10712 case CASE:
10713 case CLOSE:
10714 case COALESCE:
10715 case COLLECT:
10716 case COLUMN:
10717 case COMMENT:
10718 case COMMIT:
10719 case CONSTRUCTOR:
10720 case CONTINUE:
10721 case CONVERT:
10722 case CURRENT:
10723 case CURSOR:
10724 case DATA:
10725 case DATE:
10726 case DAY:
10727 case DECLARE:
10728 case DELETE:
10729 case DISABLE:
10730 case EDITIONABLE:
10731 case ELEMENT:
10732 case ENABLE:
10733 case ESCAPE:
10734 case EXCEPT:
10735 case EXCEPTIONS:
10736 case EXECUTE:
10737 case EXIT:
10738 case EXTERNAL:
10739 case EXTENDS:
10740 case EXTRACT:
10741 case FALSE:
10742 case FETCH:
10743 case FINAL:
10744 case FOR:
10745 case FORALL:
10746 case FORCE:
10747 case FUNCTION:
10748 case GLOBAL:
10749 case GOTO:
10750 case HASH:
10751 case HEAP:
10752 case HOUR:
10753 case IF:
10754 case IMMEDIATE:
10755 case INDICES:
10756 case INDEXTYPE:
10757 case INDICATOR:
10758 case INSERT:
10759 case INSTANTIABLE:
10760 case INTERVAL:
10761 case INVALIDATE:
10762 case ISOLATION:
10763 case JAVA:
10764 case LEVEL:
10765 case LIMIT:
10766 case LOCK:
10767 case LOOP:
10768 case MAP:
10769 case MAX:
10770 case MEMBER:
10771 case MERGE:
10772 case MIN:
10773 case MINUTE:
10774 case MLSLABEL:
10775 case MODIFY:
10776 case MOD:
10777 case MONTH:
10778 case NATURAL:
10779 case NEW:
10780 case NEW_DOT:
10781 case NO:
10782 case NONEDITIONABLE:
10783 case NOT:
10784 case NULL:
10785 case NULLIF:
10786 case OBJECT:
10787 case OID:
10788 case OPAQUE:
10789 case OPEN:
10790 case OPERATOR:
10791 case ORGANIZATION:
10792 case OTHERS:
10793 case OVERRIDING:
10794 case PACKAGE:
10795 case PARTITION:
10796 case PIPE:
10797 case PRAGMA:
10798 case PRESERVE:
10799 case PRIVATE:
10800 case PROCEDURE:
10801 case RAISE:
10802 case RANGE:
10803 case RAW:
10804 case REAL:
10805 case RECORD:
10806 case REF:
10807 case RELEASE:
10808 case RELIES_ON:
10809 case RENAME:
10810 case RESULT:
10811 case RETURN:
10812 case RETURNING:
10813 case REVERSE:
10814 case ROLLBACK:
10815 case ROW:
10816 case ROWS:
10817 case ROWID:
10818 case ROWNUM:
10819 case SAVE:
10820 case SAVEPOINT:
10821 case SECOND:
10822 case SELECT:
10823 case SELF:
10824 case SET:
10825 case SPACE:
10826 case SQL:
10827 case SQLCODE:
10828 case SQLERRM:
10829 case STATIC:
10830 case SUBTYPE:
10831 case SUBSTITUTABLE:
10832 case SUCCESSFUL:
10833 case SYSDATE:
10834 case SYS_REFCURSOR:
10835 case TEMPORARY:
10836 case TIME:
10837 case TIMESTAMP:
10838 case TIMEZONE_REGION:
10839 case TIMEZONE_ABBR:
10840 case TIMEZONE_MINUTE:
10841 case TIMEZONE_HOUR:
10842 case TRANSACTION:
10843 case TRUE:
10844 case TYPE:
10845 case UNDER:
10846 case USING:
10847 case WHILE:
10848 case YES:
10849 case SHOW:
10850 case A:
10851 case UPDATE:
10852 case DOUBLE:
10853 case DEC:
10854 case PRECISION:
10855 case INT:
10856 case NUMERIC:
10857 case NCHAR:
10858 case NVARCHAR2:
10859 case STRING:
10860 case UROWID:
10861 case VARRAY:
10862 case VARYING:
10863 case BFILE:
10864 case BLOB:
10865 case CLOB:
10866 case NCLOB:
10867 case YEAR:
10868 case LOCAL:
10869 case WITH:
10870 case ZONE:
10871 case CHARACTER:
10872 case AFTER:
10873 case BEFORE:
10874 case OLD:
10875 case PARENT:
10876 case CC_IF:
10877 case CC_ERROR:
10878 case ANALYZE:
10879 case ASSOCIATE:
10880 case AUDIT:
10881 case COMPOUND:
10882 case DATABASE:
10883 case CALL:
10884 case DDL:
10885 case DISASSOCIATE:
10886 case EACH:
10887 case FOLLOWS:
10888 case LOGOFF:
10889 case LOGON:
10890 case NESTED:
10891 case NOAUDIT:
10892 case SCHEMA:
10893 case SERVERERROR:
10894 case SHUTDOWN:
10895 case STARTUP:
10896 case STATEMENT:
10897 case STATISTICS:
10898 case SUSPEND:
10899 case TRUNCATE:
10900 case WRAPPED:
10901 case LIBRARY:
10902 case NAME:
10903 case STRUCT:
10904 case CONTEXT:
10905 case PARAMETERS:
10906 case LENGTH:
10907 case TDO:
10908 case MAXLEN:
10909 case CHARSETID:
10910 case CHARSETFORM:
10911 case ACCEPT:
10912 case ACCESSIBLE:
10913 case COPY:
10914 case DEFINE:
10915 case DISCONNECT:
10916 case HOST:
10917 case PRINT:
10918 case QUIT:
10919 case REMARK:
10920 case UNDEFINE:
10921 case VARIABLE:
10922 case WHENEVER:
10923 case ATTACH:
10924 case CAST:
10925 case TREAT:
10926 case TRIM:
10927 case LEFT:
10928 case RIGHT:
10929 case BOTH:
10930 case EMPTY:
10931 case MULTISET:
10932 case SUBMULTISET:
10933 case LEADING:
10934 case TRAILING:
10935 case CHAR_CS:
10936 case NCHAR_CS:
10937 case DBTIMEZONE:
10938 case SESSIONTIMEZONE:
10939 case AUTHENTICATED:
10940 case LINK:
10941 case SHARED:
10942 case DIRECTORY:
10943 case USER:
10944 case IDENTIFIER:
10945 case UNSIGNED_NUMERIC_LITERAL:
10946 case CHARACTER_LITERAL:
10947 case STRING_LITERAL:
10948 case QUOTED_LITERAL:
10949 ;
10950 break;
10951 default:
10952 jj_la1[129] = jj_gen;
10953 break label_27;
10954 }
10955 }
10956 jjtree.closeNodeScope(jjtn000, true);
10957 jjtc000 = false;
10958 {if (true) return jjtn000 ;}
10959 } catch (Throwable jjte000) {
10960 if (jjtc000) {
10961 jjtree.clearNodeScope(jjtn000);
10962 jjtc000 = false;
10963 } else {
10964 jjtree.popNode();
10965 }
10966 if (jjte000 instanceof RuntimeException) {
10967 {if (true) throw (RuntimeException)jjte000;}
10968 }
10969 if (jjte000 instanceof ParseException) {
10970 {if (true) throw (ParseException)jjte000;}
10971 }
10972 {if (true) throw (Error)jjte000;}
10973 } finally {
10974 if (jjtc000) {
10975 jjtree.closeNodeScope(jjtn000, true);
10976 }
10977 }
10978 throw new Error("Missing return statement in function");
10979 }
10980
10981 final public ASTElsifClause ElsifClause() throws ParseException {
10982
10983 ASTElsifClause jjtn000 = new ASTElsifClause(this, JJTELSIFCLAUSE);
10984 boolean jjtc000 = true;
10985 jjtree.openNodeScope(jjtn000);
10986 try {
10987 jj_consume_token(ELSIF);
10988 Expression();
10989 jj_consume_token(THEN);
10990 label_28:
10991 while (true) {
10992 Statement();
10993 switch (jj_nt.kind) {
10994 case 5:
10995 case 16:
10996 case 17:
10997 case 21:
10998 case REPLACE:
10999 case DEFINER:
11000 case CURRENT_USER:
11001 case LANGUAGE:
11002 case INLINE:
11003 case ADD:
11004 case AGGREGATE:
11005 case ARRAY:
11006 case AT:
11007 case ATTRIBUTE:
11008 case AUTHID:
11009 case BEGIN:
11010 case BODY:
11011 case BULK:
11012 case BYTE:
11013 case CASCADE:
11014 case CASE:
11015 case CLOSE:
11016 case COALESCE:
11017 case COLLECT:
11018 case COLUMN:
11019 case COMMENT:
11020 case COMMIT:
11021 case CONSTRUCTOR:
11022 case CONTINUE:
11023 case CONVERT:
11024 case CURRENT:
11025 case CURSOR:
11026 case DATA:
11027 case DATE:
11028 case DAY:
11029 case DECLARE:
11030 case DELETE:
11031 case DISABLE:
11032 case EDITIONABLE:
11033 case ELEMENT:
11034 case ENABLE:
11035 case ESCAPE:
11036 case EXCEPT:
11037 case EXCEPTIONS:
11038 case EXECUTE:
11039 case EXIT:
11040 case EXTERNAL:
11041 case EXTENDS:
11042 case EXTRACT:
11043 case FALSE:
11044 case FETCH:
11045 case FINAL:
11046 case FOR:
11047 case FORALL:
11048 case FORCE:
11049 case FUNCTION:
11050 case GLOBAL:
11051 case GOTO:
11052 case HASH:
11053 case HEAP:
11054 case HOUR:
11055 case IF:
11056 case IMMEDIATE:
11057 case INDICES:
11058 case INDEXTYPE:
11059 case INDICATOR:
11060 case INSERT:
11061 case INSTANTIABLE:
11062 case INTERVAL:
11063 case INVALIDATE:
11064 case ISOLATION:
11065 case JAVA:
11066 case LEVEL:
11067 case LIMIT:
11068 case LOCK:
11069 case LOOP:
11070 case MAP:
11071 case MAX:
11072 case MEMBER:
11073 case MERGE:
11074 case MIN:
11075 case MINUTE:
11076 case MLSLABEL:
11077 case MODIFY:
11078 case MOD:
11079 case MONTH:
11080 case NATURAL:
11081 case NEW:
11082 case NEW_DOT:
11083 case NO:
11084 case NONEDITIONABLE:
11085 case NOT:
11086 case NULL:
11087 case NULLIF:
11088 case OBJECT:
11089 case OID:
11090 case OPAQUE:
11091 case OPEN:
11092 case OPERATOR:
11093 case ORGANIZATION:
11094 case OTHERS:
11095 case OVERRIDING:
11096 case PACKAGE:
11097 case PARTITION:
11098 case PIPE:
11099 case PRAGMA:
11100 case PRESERVE:
11101 case PRIVATE:
11102 case PROCEDURE:
11103 case RAISE:
11104 case RANGE:
11105 case RAW:
11106 case REAL:
11107 case RECORD:
11108 case REF:
11109 case RELEASE:
11110 case RELIES_ON:
11111 case RENAME:
11112 case RESULT:
11113 case RETURN:
11114 case RETURNING:
11115 case REVERSE:
11116 case ROLLBACK:
11117 case ROW:
11118 case ROWS:
11119 case ROWID:
11120 case ROWNUM:
11121 case SAVE:
11122 case SAVEPOINT:
11123 case SECOND:
11124 case SELECT:
11125 case SELF:
11126 case SET:
11127 case SPACE:
11128 case SQL:
11129 case SQLCODE:
11130 case SQLERRM:
11131 case STATIC:
11132 case SUBTYPE:
11133 case SUBSTITUTABLE:
11134 case SUCCESSFUL:
11135 case SYSDATE:
11136 case SYS_REFCURSOR:
11137 case TEMPORARY:
11138 case TIME:
11139 case TIMESTAMP:
11140 case TIMEZONE_REGION:
11141 case TIMEZONE_ABBR:
11142 case TIMEZONE_MINUTE:
11143 case TIMEZONE_HOUR:
11144 case TRANSACTION:
11145 case TRUE:
11146 case TYPE:
11147 case UNDER:
11148 case USING:
11149 case WHILE:
11150 case YES:
11151 case SHOW:
11152 case A:
11153 case UPDATE:
11154 case DOUBLE:
11155 case DEC:
11156 case PRECISION:
11157 case INT:
11158 case NUMERIC:
11159 case NCHAR:
11160 case NVARCHAR2:
11161 case STRING:
11162 case UROWID:
11163 case VARRAY:
11164 case VARYING:
11165 case BFILE:
11166 case BLOB:
11167 case CLOB:
11168 case NCLOB:
11169 case YEAR:
11170 case LOCAL:
11171 case WITH:
11172 case ZONE:
11173 case CHARACTER:
11174 case AFTER:
11175 case BEFORE:
11176 case OLD:
11177 case PARENT:
11178 case CC_IF:
11179 case CC_ERROR:
11180 case ANALYZE:
11181 case ASSOCIATE:
11182 case AUDIT:
11183 case COMPOUND:
11184 case DATABASE:
11185 case CALL:
11186 case DDL:
11187 case DISASSOCIATE:
11188 case EACH:
11189 case FOLLOWS:
11190 case LOGOFF:
11191 case LOGON:
11192 case NESTED:
11193 case NOAUDIT:
11194 case SCHEMA:
11195 case SERVERERROR:
11196 case SHUTDOWN:
11197 case STARTUP:
11198 case STATEMENT:
11199 case STATISTICS:
11200 case SUSPEND:
11201 case TRUNCATE:
11202 case WRAPPED:
11203 case LIBRARY:
11204 case NAME:
11205 case STRUCT:
11206 case CONTEXT:
11207 case PARAMETERS:
11208 case LENGTH:
11209 case TDO:
11210 case MAXLEN:
11211 case CHARSETID:
11212 case CHARSETFORM:
11213 case ACCEPT:
11214 case ACCESSIBLE:
11215 case COPY:
11216 case DEFINE:
11217 case DISCONNECT:
11218 case HOST:
11219 case PRINT:
11220 case QUIT:
11221 case REMARK:
11222 case UNDEFINE:
11223 case VARIABLE:
11224 case WHENEVER:
11225 case ATTACH:
11226 case CAST:
11227 case TREAT:
11228 case TRIM:
11229 case LEFT:
11230 case RIGHT:
11231 case BOTH:
11232 case EMPTY:
11233 case MULTISET:
11234 case SUBMULTISET:
11235 case LEADING:
11236 case TRAILING:
11237 case CHAR_CS:
11238 case NCHAR_CS:
11239 case DBTIMEZONE:
11240 case SESSIONTIMEZONE:
11241 case AUTHENTICATED:
11242 case LINK:
11243 case SHARED:
11244 case DIRECTORY:
11245 case USER:
11246 case IDENTIFIER:
11247 case UNSIGNED_NUMERIC_LITERAL:
11248 case CHARACTER_LITERAL:
11249 case STRING_LITERAL:
11250 case QUOTED_LITERAL:
11251 ;
11252 break;
11253 default:
11254 jj_la1[130] = jj_gen;
11255 break label_28;
11256 }
11257 }
11258 jjtree.closeNodeScope(jjtn000, true);
11259 jjtc000 = false;
11260 {if (true) return jjtn000 ;}
11261 } catch (Throwable jjte000) {
11262 if (jjtc000) {
11263 jjtree.clearNodeScope(jjtn000);
11264 jjtc000 = false;
11265 } else {
11266 jjtree.popNode();
11267 }
11268 if (jjte000 instanceof RuntimeException) {
11269 {if (true) throw (RuntimeException)jjte000;}
11270 }
11271 if (jjte000 instanceof ParseException) {
11272 {if (true) throw (ParseException)jjte000;}
11273 }
11274 {if (true) throw (Error)jjte000;}
11275 } finally {
11276 if (jjtc000) {
11277 jjtree.closeNodeScope(jjtn000, true);
11278 }
11279 }
11280 throw new Error("Missing return statement in function");
11281 }
11282
11283 final public ASTLoopStatement LoopStatement() throws ParseException {
11284
11285 ASTLoopStatement jjtn000 = new ASTLoopStatement(this, JJTLOOPSTATEMENT);
11286 boolean jjtc000 = true;
11287 jjtree.openNodeScope(jjtn000);
11288 try {
11289 jj_consume_token(LOOP);
11290 label_29:
11291 while (true) {
11292 Statement();
11293 switch (jj_nt.kind) {
11294 case 5:
11295 case 16:
11296 case 17:
11297 case 21:
11298 case REPLACE:
11299 case DEFINER:
11300 case CURRENT_USER:
11301 case LANGUAGE:
11302 case INLINE:
11303 case ADD:
11304 case AGGREGATE:
11305 case ARRAY:
11306 case AT:
11307 case ATTRIBUTE:
11308 case AUTHID:
11309 case BEGIN:
11310 case BODY:
11311 case BULK:
11312 case BYTE:
11313 case CASCADE:
11314 case CASE:
11315 case CLOSE:
11316 case COALESCE:
11317 case COLLECT:
11318 case COLUMN:
11319 case COMMENT:
11320 case COMMIT:
11321 case CONSTRUCTOR:
11322 case CONTINUE:
11323 case CONVERT:
11324 case CURRENT:
11325 case CURSOR:
11326 case DATA:
11327 case DATE:
11328 case DAY:
11329 case DECLARE:
11330 case DELETE:
11331 case DISABLE:
11332 case EDITIONABLE:
11333 case ELEMENT:
11334 case ENABLE:
11335 case ESCAPE:
11336 case EXCEPT:
11337 case EXCEPTIONS:
11338 case EXECUTE:
11339 case EXIT:
11340 case EXTERNAL:
11341 case EXTENDS:
11342 case EXTRACT:
11343 case FALSE:
11344 case FETCH:
11345 case FINAL:
11346 case FOR:
11347 case FORALL:
11348 case FORCE:
11349 case FUNCTION:
11350 case GLOBAL:
11351 case GOTO:
11352 case HASH:
11353 case HEAP:
11354 case HOUR:
11355 case IF:
11356 case IMMEDIATE:
11357 case INDICES:
11358 case INDEXTYPE:
11359 case INDICATOR:
11360 case INSERT:
11361 case INSTANTIABLE:
11362 case INTERVAL:
11363 case INVALIDATE:
11364 case ISOLATION:
11365 case JAVA:
11366 case LEVEL:
11367 case LIMIT:
11368 case LOCK:
11369 case LOOP:
11370 case MAP:
11371 case MAX:
11372 case MEMBER:
11373 case MERGE:
11374 case MIN:
11375 case MINUTE:
11376 case MLSLABEL:
11377 case MODIFY:
11378 case MOD:
11379 case MONTH:
11380 case NATURAL:
11381 case NEW:
11382 case NEW_DOT:
11383 case NO:
11384 case NONEDITIONABLE:
11385 case NOT:
11386 case NULL:
11387 case NULLIF:
11388 case OBJECT:
11389 case OID:
11390 case OPAQUE:
11391 case OPEN:
11392 case OPERATOR:
11393 case ORGANIZATION:
11394 case OTHERS:
11395 case OVERRIDING:
11396 case PACKAGE:
11397 case PARTITION:
11398 case PIPE:
11399 case PRAGMA:
11400 case PRESERVE:
11401 case PRIVATE:
11402 case PROCEDURE:
11403 case RAISE:
11404 case RANGE:
11405 case RAW:
11406 case REAL:
11407 case RECORD:
11408 case REF:
11409 case RELEASE:
11410 case RELIES_ON:
11411 case RENAME:
11412 case RESULT:
11413 case RETURN:
11414 case RETURNING:
11415 case REVERSE:
11416 case ROLLBACK:
11417 case ROW:
11418 case ROWS:
11419 case ROWID:
11420 case ROWNUM:
11421 case SAVE:
11422 case SAVEPOINT:
11423 case SECOND:
11424 case SELECT:
11425 case SELF:
11426 case SET:
11427 case SPACE:
11428 case SQL:
11429 case SQLCODE:
11430 case SQLERRM:
11431 case STATIC:
11432 case SUBTYPE:
11433 case SUBSTITUTABLE:
11434 case SUCCESSFUL:
11435 case SYSDATE:
11436 case SYS_REFCURSOR:
11437 case TEMPORARY:
11438 case TIME:
11439 case TIMESTAMP:
11440 case TIMEZONE_REGION:
11441 case TIMEZONE_ABBR:
11442 case TIMEZONE_MINUTE:
11443 case TIMEZONE_HOUR:
11444 case TRANSACTION:
11445 case TRUE:
11446 case TYPE:
11447 case UNDER:
11448 case USING:
11449 case WHILE:
11450 case YES:
11451 case SHOW:
11452 case A:
11453 case UPDATE:
11454 case DOUBLE:
11455 case DEC:
11456 case PRECISION:
11457 case INT:
11458 case NUMERIC:
11459 case NCHAR:
11460 case NVARCHAR2:
11461 case STRING:
11462 case UROWID:
11463 case VARRAY:
11464 case VARYING:
11465 case BFILE:
11466 case BLOB:
11467 case CLOB:
11468 case NCLOB:
11469 case YEAR:
11470 case LOCAL:
11471 case WITH:
11472 case ZONE:
11473 case CHARACTER:
11474 case AFTER:
11475 case BEFORE:
11476 case OLD:
11477 case PARENT:
11478 case CC_IF:
11479 case CC_ERROR:
11480 case ANALYZE:
11481 case ASSOCIATE:
11482 case AUDIT:
11483 case COMPOUND:
11484 case DATABASE:
11485 case CALL:
11486 case DDL:
11487 case DISASSOCIATE:
11488 case EACH:
11489 case FOLLOWS:
11490 case LOGOFF:
11491 case LOGON:
11492 case NESTED:
11493 case NOAUDIT:
11494 case SCHEMA:
11495 case SERVERERROR:
11496 case SHUTDOWN:
11497 case STARTUP:
11498 case STATEMENT:
11499 case STATISTICS:
11500 case SUSPEND:
11501 case TRUNCATE:
11502 case WRAPPED:
11503 case LIBRARY:
11504 case NAME:
11505 case STRUCT:
11506 case CONTEXT:
11507 case PARAMETERS:
11508 case LENGTH:
11509 case TDO:
11510 case MAXLEN:
11511 case CHARSETID:
11512 case CHARSETFORM:
11513 case ACCEPT:
11514 case ACCESSIBLE:
11515 case COPY:
11516 case DEFINE:
11517 case DISCONNECT:
11518 case HOST:
11519 case PRINT:
11520 case QUIT:
11521 case REMARK:
11522 case UNDEFINE:
11523 case VARIABLE:
11524 case WHENEVER:
11525 case ATTACH:
11526 case CAST:
11527 case TREAT:
11528 case TRIM:
11529 case LEFT:
11530 case RIGHT:
11531 case BOTH:
11532 case EMPTY:
11533 case MULTISET:
11534 case SUBMULTISET:
11535 case LEADING:
11536 case TRAILING:
11537 case CHAR_CS:
11538 case NCHAR_CS:
11539 case DBTIMEZONE:
11540 case SESSIONTIMEZONE:
11541 case AUTHENTICATED:
11542 case LINK:
11543 case SHARED:
11544 case DIRECTORY:
11545 case USER:
11546 case IDENTIFIER:
11547 case UNSIGNED_NUMERIC_LITERAL:
11548 case CHARACTER_LITERAL:
11549 case STRING_LITERAL:
11550 case QUOTED_LITERAL:
11551 ;
11552 break;
11553 default:
11554 jj_la1[131] = jj_gen;
11555 break label_29;
11556 }
11557 }
11558 jj_consume_token(END);
11559 jj_consume_token(LOOP);
11560 switch (jj_nt.kind) {
11561 case IDENTIFIER:
11562 jj_consume_token(IDENTIFIER);
11563 break;
11564 default:
11565 jj_la1[132] = jj_gen;
11566 ;
11567 }
11568 jjtree.closeNodeScope(jjtn000, true);
11569 jjtc000 = false;
11570 {if (true) return jjtn000 ;}
11571 } catch (Throwable jjte000) {
11572 if (jjtc000) {
11573 jjtree.clearNodeScope(jjtn000);
11574 jjtc000 = false;
11575 } else {
11576 jjtree.popNode();
11577 }
11578 if (jjte000 instanceof RuntimeException) {
11579 {if (true) throw (RuntimeException)jjte000;}
11580 }
11581 if (jjte000 instanceof ParseException) {
11582 {if (true) throw (ParseException)jjte000;}
11583 }
11584 {if (true) throw (Error)jjte000;}
11585 } finally {
11586 if (jjtc000) {
11587 jjtree.closeNodeScope(jjtn000, true);
11588 }
11589 }
11590 throw new Error("Missing return statement in function");
11591 }
11592
11593
11594 final public ASTForStatement ForStatement() throws ParseException {
11595
11596 ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
11597 boolean jjtc000 = true;
11598 jjtree.openNodeScope(jjtn000);
11599 try {
11600 jj_consume_token(FOR);
11601 ForIndex();
11602 jj_consume_token(IN);
11603 switch (jj_nt.kind) {
11604 case REVERSE:
11605 jj_consume_token(REVERSE);
11606 break;
11607 default:
11608 jj_la1[133] = jj_gen;
11609 ;
11610 }
11611 Expression();
11612 switch (jj_nt.kind) {
11613 case 12:
11614 jj_consume_token(12);
11615 Expression();
11616 break;
11617 default:
11618 jj_la1[134] = jj_gen;
11619 ;
11620 }
11621 jj_consume_token(LOOP);
11622 label_30:
11623 while (true) {
11624 Statement();
11625 switch (jj_nt.kind) {
11626 case 5:
11627 case 16:
11628 case 17:
11629 case 21:
11630 case REPLACE:
11631 case DEFINER:
11632 case CURRENT_USER:
11633 case LANGUAGE:
11634 case INLINE:
11635 case ADD:
11636 case AGGREGATE:
11637 case ARRAY:
11638 case AT:
11639 case ATTRIBUTE:
11640 case AUTHID:
11641 case BEGIN:
11642 case BODY:
11643 case BULK:
11644 case BYTE:
11645 case CASCADE:
11646 case CASE:
11647 case CLOSE:
11648 case COALESCE:
11649 case COLLECT:
11650 case COLUMN:
11651 case COMMENT:
11652 case COMMIT:
11653 case CONSTRUCTOR:
11654 case CONTINUE:
11655 case CONVERT:
11656 case CURRENT:
11657 case CURSOR:
11658 case DATA:
11659 case DATE:
11660 case DAY:
11661 case DECLARE:
11662 case DELETE:
11663 case DISABLE:
11664 case EDITIONABLE:
11665 case ELEMENT:
11666 case ENABLE:
11667 case ESCAPE:
11668 case EXCEPT:
11669 case EXCEPTIONS:
11670 case EXECUTE:
11671 case EXIT:
11672 case EXTERNAL:
11673 case EXTENDS:
11674 case EXTRACT:
11675 case FALSE:
11676 case FETCH:
11677 case FINAL:
11678 case FOR:
11679 case FORALL:
11680 case FORCE:
11681 case FUNCTION:
11682 case GLOBAL:
11683 case GOTO:
11684 case HASH:
11685 case HEAP:
11686 case HOUR:
11687 case IF:
11688 case IMMEDIATE:
11689 case INDICES:
11690 case INDEXTYPE:
11691 case INDICATOR:
11692 case INSERT:
11693 case INSTANTIABLE:
11694 case INTERVAL:
11695 case INVALIDATE:
11696 case ISOLATION:
11697 case JAVA:
11698 case LEVEL:
11699 case LIMIT:
11700 case LOCK:
11701 case LOOP:
11702 case MAP:
11703 case MAX:
11704 case MEMBER:
11705 case MERGE:
11706 case MIN:
11707 case MINUTE:
11708 case MLSLABEL:
11709 case MODIFY:
11710 case MOD:
11711 case MONTH:
11712 case NATURAL:
11713 case NEW:
11714 case NEW_DOT:
11715 case NO:
11716 case NONEDITIONABLE:
11717 case NOT:
11718 case NULL:
11719 case NULLIF:
11720 case OBJECT:
11721 case OID:
11722 case OPAQUE:
11723 case OPEN:
11724 case OPERATOR:
11725 case ORGANIZATION:
11726 case OTHERS:
11727 case OVERRIDING:
11728 case PACKAGE:
11729 case PARTITION:
11730 case PIPE:
11731 case PRAGMA:
11732 case PRESERVE:
11733 case PRIVATE:
11734 case PROCEDURE:
11735 case RAISE:
11736 case RANGE:
11737 case RAW:
11738 case REAL:
11739 case RECORD:
11740 case REF:
11741 case RELEASE:
11742 case RELIES_ON:
11743 case RENAME:
11744 case RESULT:
11745 case RETURN:
11746 case RETURNING:
11747 case REVERSE:
11748 case ROLLBACK:
11749 case ROW:
11750 case ROWS:
11751 case ROWID:
11752 case ROWNUM:
11753 case SAVE:
11754 case SAVEPOINT:
11755 case SECOND:
11756 case SELECT:
11757 case SELF:
11758 case SET:
11759 case SPACE:
11760 case SQL:
11761 case SQLCODE:
11762 case SQLERRM:
11763 case STATIC:
11764 case SUBTYPE:
11765 case SUBSTITUTABLE:
11766 case SUCCESSFUL:
11767 case SYSDATE:
11768 case SYS_REFCURSOR:
11769 case TEMPORARY:
11770 case TIME:
11771 case TIMESTAMP:
11772 case TIMEZONE_REGION:
11773 case TIMEZONE_ABBR:
11774 case TIMEZONE_MINUTE:
11775 case TIMEZONE_HOUR:
11776 case TRANSACTION:
11777 case TRUE:
11778 case TYPE:
11779 case UNDER:
11780 case USING:
11781 case WHILE:
11782 case YES:
11783 case SHOW:
11784 case A:
11785 case UPDATE:
11786 case DOUBLE:
11787 case DEC:
11788 case PRECISION:
11789 case INT:
11790 case NUMERIC:
11791 case NCHAR:
11792 case NVARCHAR2:
11793 case STRING:
11794 case UROWID:
11795 case VARRAY:
11796 case VARYING:
11797 case BFILE:
11798 case BLOB:
11799 case CLOB:
11800 case NCLOB:
11801 case YEAR:
11802 case LOCAL:
11803 case WITH:
11804 case ZONE:
11805 case CHARACTER:
11806 case AFTER:
11807 case BEFORE:
11808 case OLD:
11809 case PARENT:
11810 case CC_IF:
11811 case CC_ERROR:
11812 case ANALYZE:
11813 case ASSOCIATE:
11814 case AUDIT:
11815 case COMPOUND:
11816 case DATABASE:
11817 case CALL:
11818 case DDL:
11819 case DISASSOCIATE:
11820 case EACH:
11821 case FOLLOWS:
11822 case LOGOFF:
11823 case LOGON:
11824 case NESTED:
11825 case NOAUDIT:
11826 case SCHEMA:
11827 case SERVERERROR:
11828 case SHUTDOWN:
11829 case STARTUP:
11830 case STATEMENT:
11831 case STATISTICS:
11832 case SUSPEND:
11833 case TRUNCATE:
11834 case WRAPPED:
11835 case LIBRARY:
11836 case NAME:
11837 case STRUCT:
11838 case CONTEXT:
11839 case PARAMETERS:
11840 case LENGTH:
11841 case TDO:
11842 case MAXLEN:
11843 case CHARSETID:
11844 case CHARSETFORM:
11845 case ACCEPT:
11846 case ACCESSIBLE:
11847 case COPY:
11848 case DEFINE:
11849 case DISCONNECT:
11850 case HOST:
11851 case PRINT:
11852 case QUIT:
11853 case REMARK:
11854 case UNDEFINE:
11855 case VARIABLE:
11856 case WHENEVER:
11857 case ATTACH:
11858 case CAST:
11859 case TREAT:
11860 case TRIM:
11861 case LEFT:
11862 case RIGHT:
11863 case BOTH:
11864 case EMPTY:
11865 case MULTISET:
11866 case SUBMULTISET:
11867 case LEADING:
11868 case TRAILING:
11869 case CHAR_CS:
11870 case NCHAR_CS:
11871 case DBTIMEZONE:
11872 case SESSIONTIMEZONE:
11873 case AUTHENTICATED:
11874 case LINK:
11875 case SHARED:
11876 case DIRECTORY:
11877 case USER:
11878 case IDENTIFIER:
11879 case UNSIGNED_NUMERIC_LITERAL:
11880 case CHARACTER_LITERAL:
11881 case STRING_LITERAL:
11882 case QUOTED_LITERAL:
11883 ;
11884 break;
11885 default:
11886 jj_la1[135] = jj_gen;
11887 break label_30;
11888 }
11889 }
11890 jj_consume_token(END);
11891 jj_consume_token(LOOP);
11892 switch (jj_nt.kind) {
11893 case IDENTIFIER:
11894 jj_consume_token(IDENTIFIER);
11895 break;
11896 default:
11897 jj_la1[136] = jj_gen;
11898 ;
11899 }
11900 jjtree.closeNodeScope(jjtn000, true);
11901 jjtc000 = false;
11902 {if (true) return jjtn000 ;}
11903 } catch (Throwable jjte000) {
11904 if (jjtc000) {
11905 jjtree.clearNodeScope(jjtn000);
11906 jjtc000 = false;
11907 } else {
11908 jjtree.popNode();
11909 }
11910 if (jjte000 instanceof RuntimeException) {
11911 {if (true) throw (RuntimeException)jjte000;}
11912 }
11913 if (jjte000 instanceof ParseException) {
11914 {if (true) throw (ParseException)jjte000;}
11915 }
11916 {if (true) throw (Error)jjte000;}
11917 } finally {
11918 if (jjtc000) {
11919 jjtree.closeNodeScope(jjtn000, true);
11920 }
11921 }
11922 throw new Error("Missing return statement in function");
11923 }
11924
11925 final public ASTWhileStatement WhileStatement() throws ParseException {
11926
11927 ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
11928 boolean jjtc000 = true;
11929 jjtree.openNodeScope(jjtn000);
11930 try {
11931 jj_consume_token(WHILE);
11932 Expression();
11933 jj_consume_token(LOOP);
11934 label_31:
11935 while (true) {
11936 Statement();
11937 switch (jj_nt.kind) {
11938 case 5:
11939 case 16:
11940 case 17:
11941 case 21:
11942 case REPLACE:
11943 case DEFINER:
11944 case CURRENT_USER:
11945 case LANGUAGE:
11946 case INLINE:
11947 case ADD:
11948 case AGGREGATE:
11949 case ARRAY:
11950 case AT:
11951 case ATTRIBUTE:
11952 case AUTHID:
11953 case BEGIN:
11954 case BODY:
11955 case BULK:
11956 case BYTE:
11957 case CASCADE:
11958 case CASE:
11959 case CLOSE:
11960 case COALESCE:
11961 case COLLECT:
11962 case COLUMN:
11963 case COMMENT:
11964 case COMMIT:
11965 case CONSTRUCTOR:
11966 case CONTINUE:
11967 case CONVERT:
11968 case CURRENT:
11969 case CURSOR:
11970 case DATA:
11971 case DATE:
11972 case DAY:
11973 case DECLARE:
11974 case DELETE:
11975 case DISABLE:
11976 case EDITIONABLE:
11977 case ELEMENT:
11978 case ENABLE:
11979 case ESCAPE:
11980 case EXCEPT:
11981 case EXCEPTIONS:
11982 case EXECUTE:
11983 case EXIT:
11984 case EXTERNAL:
11985 case EXTENDS:
11986 case EXTRACT:
11987 case FALSE:
11988 case FETCH:
11989 case FINAL:
11990 case FOR:
11991 case FORALL:
11992 case FORCE:
11993 case FUNCTION:
11994 case GLOBAL:
11995 case GOTO:
11996 case HASH:
11997 case HEAP:
11998 case HOUR:
11999 case IF:
12000 case IMMEDIATE:
12001 case INDICES:
12002 case INDEXTYPE:
12003 case INDICATOR:
12004 case INSERT:
12005 case INSTANTIABLE:
12006 case INTERVAL:
12007 case INVALIDATE:
12008 case ISOLATION:
12009 case JAVA:
12010 case LEVEL:
12011 case LIMIT:
12012 case LOCK:
12013 case LOOP:
12014 case MAP:
12015 case MAX:
12016 case MEMBER:
12017 case MERGE:
12018 case MIN:
12019 case MINUTE:
12020 case MLSLABEL:
12021 case MODIFY:
12022 case MOD:
12023 case MONTH:
12024 case NATURAL:
12025 case NEW:
12026 case NEW_DOT:
12027 case NO:
12028 case NONEDITIONABLE:
12029 case NOT:
12030 case NULL:
12031 case NULLIF:
12032 case OBJECT:
12033 case OID:
12034 case OPAQUE:
12035 case OPEN:
12036 case OPERATOR:
12037 case ORGANIZATION:
12038 case OTHERS:
12039 case OVERRIDING:
12040 case PACKAGE:
12041 case PARTITION:
12042 case PIPE:
12043 case PRAGMA:
12044 case PRESERVE:
12045 case PRIVATE:
12046 case PROCEDURE:
12047 case RAISE:
12048 case RANGE:
12049 case RAW:
12050 case REAL:
12051 case RECORD:
12052 case REF:
12053 case RELEASE:
12054 case RELIES_ON:
12055 case RENAME:
12056 case RESULT:
12057 case RETURN:
12058 case RETURNING:
12059 case REVERSE:
12060 case ROLLBACK:
12061 case ROW:
12062 case ROWS:
12063 case ROWID:
12064 case ROWNUM:
12065 case SAVE:
12066 case SAVEPOINT:
12067 case SECOND:
12068 case SELECT:
12069 case SELF:
12070 case SET:
12071 case SPACE:
12072 case SQL:
12073 case SQLCODE:
12074 case SQLERRM:
12075 case STATIC:
12076 case SUBTYPE:
12077 case SUBSTITUTABLE:
12078 case SUCCESSFUL:
12079 case SYSDATE:
12080 case SYS_REFCURSOR:
12081 case TEMPORARY:
12082 case TIME:
12083 case TIMESTAMP:
12084 case TIMEZONE_REGION:
12085 case TIMEZONE_ABBR:
12086 case TIMEZONE_MINUTE:
12087 case TIMEZONE_HOUR:
12088 case TRANSACTION:
12089 case TRUE:
12090 case TYPE:
12091 case UNDER:
12092 case USING:
12093 case WHILE:
12094 case YES:
12095 case SHOW:
12096 case A:
12097 case UPDATE:
12098 case DOUBLE:
12099 case DEC:
12100 case PRECISION:
12101 case INT:
12102 case NUMERIC:
12103 case NCHAR:
12104 case NVARCHAR2:
12105 case STRING:
12106 case UROWID:
12107 case VARRAY:
12108 case VARYING:
12109 case BFILE:
12110 case BLOB:
12111 case CLOB:
12112 case NCLOB:
12113 case YEAR:
12114 case LOCAL:
12115 case WITH:
12116 case ZONE:
12117 case CHARACTER:
12118 case AFTER:
12119 case BEFORE:
12120 case OLD:
12121 case PARENT:
12122 case CC_IF:
12123 case CC_ERROR:
12124 case ANALYZE:
12125 case ASSOCIATE:
12126 case AUDIT:
12127 case COMPOUND:
12128 case DATABASE:
12129 case CALL:
12130 case DDL:
12131 case DISASSOCIATE:
12132 case EACH:
12133 case FOLLOWS:
12134 case LOGOFF:
12135 case LOGON:
12136 case NESTED:
12137 case NOAUDIT:
12138 case SCHEMA:
12139 case SERVERERROR:
12140 case SHUTDOWN:
12141 case STARTUP:
12142 case STATEMENT:
12143 case STATISTICS:
12144 case SUSPEND:
12145 case TRUNCATE:
12146 case WRAPPED:
12147 case LIBRARY:
12148 case NAME:
12149 case STRUCT:
12150 case CONTEXT:
12151 case PARAMETERS:
12152 case LENGTH:
12153 case TDO:
12154 case MAXLEN:
12155 case CHARSETID:
12156 case CHARSETFORM:
12157 case ACCEPT:
12158 case ACCESSIBLE:
12159 case COPY:
12160 case DEFINE:
12161 case DISCONNECT:
12162 case HOST:
12163 case PRINT:
12164 case QUIT:
12165 case REMARK:
12166 case UNDEFINE:
12167 case VARIABLE:
12168 case WHENEVER:
12169 case ATTACH:
12170 case CAST:
12171 case TREAT:
12172 case TRIM:
12173 case LEFT:
12174 case RIGHT:
12175 case BOTH:
12176 case EMPTY:
12177 case MULTISET:
12178 case SUBMULTISET:
12179 case LEADING:
12180 case TRAILING:
12181 case CHAR_CS:
12182 case NCHAR_CS:
12183 case DBTIMEZONE:
12184 case SESSIONTIMEZONE:
12185 case AUTHENTICATED:
12186 case LINK:
12187 case SHARED:
12188 case DIRECTORY:
12189 case USER:
12190 case IDENTIFIER:
12191 case UNSIGNED_NUMERIC_LITERAL:
12192 case CHARACTER_LITERAL:
12193 case STRING_LITERAL:
12194 case QUOTED_LITERAL:
12195 ;
12196 break;
12197 default:
12198 jj_la1[137] = jj_gen;
12199 break label_31;
12200 }
12201 }
12202 jj_consume_token(END);
12203 jj_consume_token(LOOP);
12204 switch (jj_nt.kind) {
12205 case IDENTIFIER:
12206 jj_consume_token(IDENTIFIER);
12207 break;
12208 default:
12209 jj_la1[138] = jj_gen;
12210 ;
12211 }
12212 jjtree.closeNodeScope(jjtn000, true);
12213 jjtc000 = false;
12214 {if (true) return jjtn000 ;}
12215 } catch (Throwable jjte000) {
12216 if (jjtc000) {
12217 jjtree.clearNodeScope(jjtn000);
12218 jjtc000 = false;
12219 } else {
12220 jjtree.popNode();
12221 }
12222 if (jjte000 instanceof RuntimeException) {
12223 {if (true) throw (RuntimeException)jjte000;}
12224 }
12225 if (jjte000 instanceof ParseException) {
12226 {if (true) throw (ParseException)jjte000;}
12227 }
12228 {if (true) throw (Error)jjte000;}
12229 } finally {
12230 if (jjtc000) {
12231 jjtree.closeNodeScope(jjtn000, true);
12232 }
12233 }
12234 throw new Error("Missing return statement in function");
12235 }
12236
12237 final public ASTIfStatement IfStatement() throws ParseException {
12238
12239 ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
12240 boolean jjtc000 = true;
12241 jjtree.openNodeScope(jjtn000);
12242 try {
12243 jj_consume_token(IF);
12244 Expression();
12245 jj_consume_token(THEN);
12246 label_32:
12247 while (true) {
12248 Statement();
12249 switch (jj_nt.kind) {
12250 case 5:
12251 case 16:
12252 case 17:
12253 case 21:
12254 case REPLACE:
12255 case DEFINER:
12256 case CURRENT_USER:
12257 case LANGUAGE:
12258 case INLINE:
12259 case ADD:
12260 case AGGREGATE:
12261 case ARRAY:
12262 case AT:
12263 case ATTRIBUTE:
12264 case AUTHID:
12265 case BEGIN:
12266 case BODY:
12267 case BULK:
12268 case BYTE:
12269 case CASCADE:
12270 case CASE:
12271 case CLOSE:
12272 case COALESCE:
12273 case COLLECT:
12274 case COLUMN:
12275 case COMMENT:
12276 case COMMIT:
12277 case CONSTRUCTOR:
12278 case CONTINUE:
12279 case CONVERT:
12280 case CURRENT:
12281 case CURSOR:
12282 case DATA:
12283 case DATE:
12284 case DAY:
12285 case DECLARE:
12286 case DELETE:
12287 case DISABLE:
12288 case EDITIONABLE:
12289 case ELEMENT:
12290 case ENABLE:
12291 case ESCAPE:
12292 case EXCEPT:
12293 case EXCEPTIONS:
12294 case EXECUTE:
12295 case EXIT:
12296 case EXTERNAL:
12297 case EXTENDS:
12298 case EXTRACT:
12299 case FALSE:
12300 case FETCH:
12301 case FINAL:
12302 case FOR:
12303 case FORALL:
12304 case FORCE:
12305 case FUNCTION:
12306 case GLOBAL:
12307 case GOTO:
12308 case HASH:
12309 case HEAP:
12310 case HOUR:
12311 case IF:
12312 case IMMEDIATE:
12313 case INDICES:
12314 case INDEXTYPE:
12315 case INDICATOR:
12316 case INSERT:
12317 case INSTANTIABLE:
12318 case INTERVAL:
12319 case INVALIDATE:
12320 case ISOLATION:
12321 case JAVA:
12322 case LEVEL:
12323 case LIMIT:
12324 case LOCK:
12325 case LOOP:
12326 case MAP:
12327 case MAX:
12328 case MEMBER:
12329 case MERGE:
12330 case MIN:
12331 case MINUTE:
12332 case MLSLABEL:
12333 case MODIFY:
12334 case MOD:
12335 case MONTH:
12336 case NATURAL:
12337 case NEW:
12338 case NEW_DOT:
12339 case NO:
12340 case NONEDITIONABLE:
12341 case NOT:
12342 case NULL:
12343 case NULLIF:
12344 case OBJECT:
12345 case OID:
12346 case OPAQUE:
12347 case OPEN:
12348 case OPERATOR:
12349 case ORGANIZATION:
12350 case OTHERS:
12351 case OVERRIDING:
12352 case PACKAGE:
12353 case PARTITION:
12354 case PIPE:
12355 case PRAGMA:
12356 case PRESERVE:
12357 case PRIVATE:
12358 case PROCEDURE:
12359 case RAISE:
12360 case RANGE:
12361 case RAW:
12362 case REAL:
12363 case RECORD:
12364 case REF:
12365 case RELEASE:
12366 case RELIES_ON:
12367 case RENAME:
12368 case RESULT:
12369 case RETURN:
12370 case RETURNING:
12371 case REVERSE:
12372 case ROLLBACK:
12373 case ROW:
12374 case ROWS:
12375 case ROWID:
12376 case ROWNUM:
12377 case SAVE:
12378 case SAVEPOINT:
12379 case SECOND:
12380 case SELECT:
12381 case SELF:
12382 case SET:
12383 case SPACE:
12384 case SQL:
12385 case SQLCODE:
12386 case SQLERRM:
12387 case STATIC:
12388 case SUBTYPE:
12389 case SUBSTITUTABLE:
12390 case SUCCESSFUL:
12391 case SYSDATE:
12392 case SYS_REFCURSOR:
12393 case TEMPORARY:
12394 case TIME:
12395 case TIMESTAMP:
12396 case TIMEZONE_REGION:
12397 case TIMEZONE_ABBR:
12398 case TIMEZONE_MINUTE:
12399 case TIMEZONE_HOUR:
12400 case TRANSACTION:
12401 case TRUE:
12402 case TYPE:
12403 case UNDER:
12404 case USING:
12405 case WHILE:
12406 case YES:
12407 case SHOW:
12408 case A:
12409 case UPDATE:
12410 case DOUBLE:
12411 case DEC:
12412 case PRECISION:
12413 case INT:
12414 case NUMERIC:
12415 case NCHAR:
12416 case NVARCHAR2:
12417 case STRING:
12418 case UROWID:
12419 case VARRAY:
12420 case VARYING:
12421 case BFILE:
12422 case BLOB:
12423 case CLOB:
12424 case NCLOB:
12425 case YEAR:
12426 case LOCAL:
12427 case WITH:
12428 case ZONE:
12429 case CHARACTER:
12430 case AFTER:
12431 case BEFORE:
12432 case OLD:
12433 case PARENT:
12434 case CC_IF:
12435 case CC_ERROR:
12436 case ANALYZE:
12437 case ASSOCIATE:
12438 case AUDIT:
12439 case COMPOUND:
12440 case DATABASE:
12441 case CALL:
12442 case DDL:
12443 case DISASSOCIATE:
12444 case EACH:
12445 case FOLLOWS:
12446 case LOGOFF:
12447 case LOGON:
12448 case NESTED:
12449 case NOAUDIT:
12450 case SCHEMA:
12451 case SERVERERROR:
12452 case SHUTDOWN:
12453 case STARTUP:
12454 case STATEMENT:
12455 case STATISTICS:
12456 case SUSPEND:
12457 case TRUNCATE:
12458 case WRAPPED:
12459 case LIBRARY:
12460 case NAME:
12461 case STRUCT:
12462 case CONTEXT:
12463 case PARAMETERS:
12464 case LENGTH:
12465 case TDO:
12466 case MAXLEN:
12467 case CHARSETID:
12468 case CHARSETFORM:
12469 case ACCEPT:
12470 case ACCESSIBLE:
12471 case COPY:
12472 case DEFINE:
12473 case DISCONNECT:
12474 case HOST:
12475 case PRINT:
12476 case QUIT:
12477 case REMARK:
12478 case UNDEFINE:
12479 case VARIABLE:
12480 case WHENEVER:
12481 case ATTACH:
12482 case CAST:
12483 case TREAT:
12484 case TRIM:
12485 case LEFT:
12486 case RIGHT:
12487 case BOTH:
12488 case EMPTY:
12489 case MULTISET:
12490 case SUBMULTISET:
12491 case LEADING:
12492 case TRAILING:
12493 case CHAR_CS:
12494 case NCHAR_CS:
12495 case DBTIMEZONE:
12496 case SESSIONTIMEZONE:
12497 case AUTHENTICATED:
12498 case LINK:
12499 case SHARED:
12500 case DIRECTORY:
12501 case USER:
12502 case IDENTIFIER:
12503 case UNSIGNED_NUMERIC_LITERAL:
12504 case CHARACTER_LITERAL:
12505 case STRING_LITERAL:
12506 case QUOTED_LITERAL:
12507 ;
12508 break;
12509 default:
12510 jj_la1[139] = jj_gen;
12511 break label_32;
12512 }
12513 }
12514 label_33:
12515 while (true) {
12516 switch (jj_nt.kind) {
12517 case ELSIF:
12518 ;
12519 break;
12520 default:
12521 jj_la1[140] = jj_gen;
12522 break label_33;
12523 }
12524 ElsifClause();
12525 jjtn000.setHasElse();
12526 }
12527 switch (jj_nt.kind) {
12528 case ELSE:
12529 ElseClause();
12530 jjtn000.setHasElse();
12531 break;
12532 default:
12533 jj_la1[141] = jj_gen;
12534 ;
12535 }
12536 jj_consume_token(END);
12537 jj_consume_token(IF);
12538 jjtree.closeNodeScope(jjtn000, true);
12539 jjtc000 = false;
12540 {if (true) return jjtn000 ;}
12541 } catch (Throwable jjte000) {
12542 if (jjtc000) {
12543 jjtree.clearNodeScope(jjtn000);
12544 jjtc000 = false;
12545 } else {
12546 jjtree.popNode();
12547 }
12548 if (jjte000 instanceof RuntimeException) {
12549 {if (true) throw (RuntimeException)jjte000;}
12550 }
12551 if (jjte000 instanceof ParseException) {
12552 {if (true) throw (ParseException)jjte000;}
12553 }
12554 {if (true) throw (Error)jjte000;}
12555 } finally {
12556 if (jjtc000) {
12557 jjtree.closeNodeScope(jjtn000, true);
12558 }
12559 }
12560 throw new Error("Missing return statement in function");
12561 }
12562
12563
12564
12565
12566
12567 final public ASTForIndex ForIndex() throws ParseException {
12568
12569 ASTForIndex jjtn000 = new ASTForIndex(this, JJTFORINDEX);
12570 boolean jjtc000 = true;
12571 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
12572 try {
12573 simpleNode = ID();
12574 jjtree.closeNodeScope(jjtn000, true);
12575 jjtc000 = false;
12576 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
12577 } catch (Throwable jjte000) {
12578 if (jjtc000) {
12579 jjtree.clearNodeScope(jjtn000);
12580 jjtc000 = false;
12581 } else {
12582 jjtree.popNode();
12583 }
12584 if (jjte000 instanceof RuntimeException) {
12585 {if (true) throw (RuntimeException)jjte000;}
12586 }
12587 if (jjte000 instanceof ParseException) {
12588 {if (true) throw (ParseException)jjte000;}
12589 }
12590 {if (true) throw (Error)jjte000;}
12591 } finally {
12592 if (jjtc000) {
12593 jjtree.closeNodeScope(jjtn000, true);
12594 }
12595 }
12596 throw new Error("Missing return statement in function");
12597 }
12598
12599
12600
12601
12602 final public ASTForAllIndex ForAllIndex() throws ParseException {
12603
12604 ASTForAllIndex jjtn000 = new ASTForAllIndex(this, JJTFORALLINDEX);
12605 boolean jjtc000 = true;
12606 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
12607 try {
12608 simpleNode = ID();
12609 jjtree.closeNodeScope(jjtn000, true);
12610 jjtc000 = false;
12611 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
12612 } catch (Throwable jjte000) {
12613 if (jjtc000) {
12614 jjtree.clearNodeScope(jjtn000);
12615 jjtc000 = false;
12616 } else {
12617 jjtree.popNode();
12618 }
12619 if (jjte000 instanceof RuntimeException) {
12620 {if (true) throw (RuntimeException)jjte000;}
12621 }
12622 if (jjte000 instanceof ParseException) {
12623 {if (true) throw (ParseException)jjte000;}
12624 }
12625 {if (true) throw (Error)jjte000;}
12626 } finally {
12627 if (jjtc000) {
12628 jjtree.closeNodeScope(jjtn000, true);
12629 }
12630 }
12631 throw new Error("Missing return statement in function");
12632 }
12633
12634 final public ASTForAllStatement ForAllStatement() throws ParseException {
12635
12636 ASTForAllStatement jjtn000 = new ASTForAllStatement(this, JJTFORALLSTATEMENT);
12637 boolean jjtc000 = true;
12638 jjtree.openNodeScope(jjtn000);
12639 try {
12640 jj_consume_token(FORALL);
12641 ForAllIndex();
12642 jj_consume_token(IN);
12643 switch (jj_nt.kind) {
12644 case INDICES:
12645 case VALUES:
12646 switch (jj_nt.kind) {
12647 case INDICES:
12648 jj_consume_token(INDICES);
12649 break;
12650 case VALUES:
12651 jj_consume_token(VALUES);
12652 break;
12653 default:
12654 jj_la1[142] = jj_gen;
12655 jj_consume_token(-1);
12656 throw new ParseException();
12657 }
12658 jj_consume_token(OF);
12659 Expression();
12660 break;
12661 case 5:
12662 case 16:
12663 case 17:
12664 case REPLACE:
12665 case DEFINER:
12666 case CURRENT_USER:
12667 case LANGUAGE:
12668 case INLINE:
12669 case ADD:
12670 case AGGREGATE:
12671 case ARRAY:
12672 case AT:
12673 case ATTRIBUTE:
12674 case AUTHID:
12675 case BODY:
12676 case BULK:
12677 case BYTE:
12678 case CASCADE:
12679 case CASE:
12680 case CLOSE:
12681 case COALESCE:
12682 case COLLECT:
12683 case COLUMN:
12684 case COMMENT:
12685 case COMMIT:
12686 case CONSTRUCTOR:
12687 case CONTINUE:
12688 case CONVERT:
12689 case CURRENT:
12690 case CURSOR:
12691 case DATA:
12692 case DATE:
12693 case DAY:
12694 case DISABLE:
12695 case EDITIONABLE:
12696 case ELEMENT:
12697 case ENABLE:
12698 case ESCAPE:
12699 case EXCEPT:
12700 case EXCEPTIONS:
12701 case EXIT:
12702 case EXTERNAL:
12703 case EXTENDS:
12704 case EXTRACT:
12705 case FALSE:
12706 case FINAL:
12707 case FORCE:
12708 case FUNCTION:
12709 case GLOBAL:
12710 case HASH:
12711 case HEAP:
12712 case HOUR:
12713 case IMMEDIATE:
12714 case INDEXTYPE:
12715 case INDICATOR:
12716 case INSTANTIABLE:
12717 case INTERVAL:
12718 case INVALIDATE:
12719 case ISOLATION:
12720 case JAVA:
12721 case LEVEL:
12722 case LIMIT:
12723 case LOOP:
12724 case MAP:
12725 case MAX:
12726 case MEMBER:
12727 case MERGE:
12728 case MIN:
12729 case MINUTE:
12730 case MLSLABEL:
12731 case MODIFY:
12732 case MOD:
12733 case MONTH:
12734 case NATURAL:
12735 case NEW:
12736 case NEW_DOT:
12737 case NO:
12738 case NONEDITIONABLE:
12739 case NOT:
12740 case NULL:
12741 case NULLIF:
12742 case OBJECT:
12743 case OID:
12744 case OPAQUE:
12745 case OPEN:
12746 case OPERATOR:
12747 case ORGANIZATION:
12748 case OTHERS:
12749 case OVERRIDING:
12750 case PACKAGE:
12751 case PARTITION:
12752 case PRESERVE:
12753 case PRIVATE:
12754 case PROCEDURE:
12755 case RANGE:
12756 case RAW:
12757 case REAL:
12758 case RECORD:
12759 case REF:
12760 case RELEASE:
12761 case RELIES_ON:
12762 case RENAME:
12763 case RESULT:
12764 case RETURN:
12765 case RETURNING:
12766 case REVERSE:
12767 case ROLLBACK:
12768 case ROW:
12769 case ROWS:
12770 case ROWID:
12771 case ROWNUM:
12772 case SAVE:
12773 case SAVEPOINT:
12774 case SECOND:
12775 case SELECT:
12776 case SELF:
12777 case SET:
12778 case SPACE:
12779 case SQL:
12780 case SQLCODE:
12781 case SQLERRM:
12782 case STATIC:
12783 case SUBTYPE:
12784 case SUBSTITUTABLE:
12785 case SUCCESSFUL:
12786 case SYSDATE:
12787 case SYS_REFCURSOR:
12788 case TEMPORARY:
12789 case TIME:
12790 case TIMESTAMP:
12791 case TIMEZONE_REGION:
12792 case TIMEZONE_ABBR:
12793 case TIMEZONE_MINUTE:
12794 case TIMEZONE_HOUR:
12795 case TRANSACTION:
12796 case TRUE:
12797 case TYPE:
12798 case UNDER:
12799 case USING:
12800 case YES:
12801 case SHOW:
12802 case A:
12803 case DOUBLE:
12804 case DEC:
12805 case PRECISION:
12806 case INT:
12807 case NUMERIC:
12808 case NCHAR:
12809 case NVARCHAR2:
12810 case STRING:
12811 case UROWID:
12812 case VARRAY:
12813 case VARYING:
12814 case BFILE:
12815 case BLOB:
12816 case CLOB:
12817 case NCLOB:
12818 case YEAR:
12819 case LOCAL:
12820 case WITH:
12821 case ZONE:
12822 case CHARACTER:
12823 case AFTER:
12824 case BEFORE:
12825 case OLD:
12826 case PARENT:
12827 case CC_IF:
12828 case ANALYZE:
12829 case ASSOCIATE:
12830 case AUDIT:
12831 case COMPOUND:
12832 case DATABASE:
12833 case CALL:
12834 case DDL:
12835 case DISASSOCIATE:
12836 case EACH:
12837 case FOLLOWS:
12838 case LOGOFF:
12839 case LOGON:
12840 case NESTED:
12841 case NOAUDIT:
12842 case SCHEMA:
12843 case SERVERERROR:
12844 case SHUTDOWN:
12845 case STARTUP:
12846 case STATEMENT:
12847 case STATISTICS:
12848 case SUSPEND:
12849 case TRUNCATE:
12850 case WRAPPED:
12851 case LIBRARY:
12852 case NAME:
12853 case STRUCT:
12854 case CONTEXT:
12855 case PARAMETERS:
12856 case LENGTH:
12857 case TDO:
12858 case MAXLEN:
12859 case CHARSETID:
12860 case CHARSETFORM:
12861 case ACCEPT:
12862 case ACCESSIBLE:
12863 case COPY:
12864 case DEFINE:
12865 case DISCONNECT:
12866 case HOST:
12867 case PRINT:
12868 case QUIT:
12869 case REMARK:
12870 case UNDEFINE:
12871 case VARIABLE:
12872 case WHENEVER:
12873 case ATTACH:
12874 case CAST:
12875 case TREAT:
12876 case TRIM:
12877 case LEFT:
12878 case RIGHT:
12879 case BOTH:
12880 case EMPTY:
12881 case MULTISET:
12882 case SUBMULTISET:
12883 case LEADING:
12884 case TRAILING:
12885 case CHAR_CS:
12886 case NCHAR_CS:
12887 case DBTIMEZONE:
12888 case SESSIONTIMEZONE:
12889 case AUTHENTICATED:
12890 case LINK:
12891 case SHARED:
12892 case DIRECTORY:
12893 case USER:
12894 case IDENTIFIER:
12895 case UNSIGNED_NUMERIC_LITERAL:
12896 case CHARACTER_LITERAL:
12897 case STRING_LITERAL:
12898 case QUOTED_LITERAL:
12899 Expression();
12900 switch (jj_nt.kind) {
12901 case 12:
12902 jj_consume_token(12);
12903 Expression();
12904 break;
12905 default:
12906 jj_la1[143] = jj_gen;
12907 ;
12908 }
12909 break;
12910 default:
12911 jj_la1[144] = jj_gen;
12912 jj_consume_token(-1);
12913 throw new ParseException();
12914 }
12915 switch (jj_nt.kind) {
12916 case SAVE:
12917 jj_consume_token(SAVE);
12918 jj_consume_token(EXCEPTIONS);
12919 break;
12920 default:
12921 jj_la1[145] = jj_gen;
12922 ;
12923 }
12924 SqlStatement(null,";");
12925 jjtree.closeNodeScope(jjtn000, true);
12926 jjtc000 = false;
12927 {if (true) return jjtn000 ;}
12928 } catch (Throwable jjte000) {
12929 if (jjtc000) {
12930 jjtree.clearNodeScope(jjtn000);
12931 jjtc000 = false;
12932 } else {
12933 jjtree.popNode();
12934 }
12935 if (jjte000 instanceof RuntimeException) {
12936 {if (true) throw (RuntimeException)jjte000;}
12937 }
12938 if (jjte000 instanceof ParseException) {
12939 {if (true) throw (ParseException)jjte000;}
12940 }
12941 {if (true) throw (Error)jjte000;}
12942 } finally {
12943 if (jjtc000) {
12944 jjtree.closeNodeScope(jjtn000, true);
12945 }
12946 }
12947 throw new Error("Missing return statement in function");
12948 }
12949
12950 final public ASTGotoStatement GotoStatement() throws ParseException {
12951
12952 ASTGotoStatement jjtn000 = new ASTGotoStatement(this, JJTGOTOSTATEMENT);
12953 boolean jjtc000 = true;
12954 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
12955 try {
12956 jj_consume_token(GOTO);
12957 label = QualifiedName();
12958 jjtree.closeNodeScope(jjtn000, true);
12959 jjtc000 = false;
12960 jjtn000.setImage(label.getImage()) ; {if (true) return jjtn000 ;}
12961 } catch (Throwable jjte000) {
12962 if (jjtc000) {
12963 jjtree.clearNodeScope(jjtn000);
12964 jjtc000 = false;
12965 } else {
12966 jjtree.popNode();
12967 }
12968 if (jjte000 instanceof RuntimeException) {
12969 {if (true) throw (RuntimeException)jjte000;}
12970 }
12971 if (jjte000 instanceof ParseException) {
12972 {if (true) throw (ParseException)jjte000;}
12973 }
12974 {if (true) throw (Error)jjte000;}
12975 } finally {
12976 if (jjtc000) {
12977 jjtree.closeNodeScope(jjtn000, true);
12978 }
12979 }
12980 throw new Error("Missing return statement in function");
12981 }
12982
12983 final public ASTReturnStatement ReturnStatement() throws ParseException {
12984
12985 ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
12986 boolean jjtc000 = true;
12987 jjtree.openNodeScope(jjtn000);
12988 try {
12989 jj_consume_token(RETURN);
12990 switch (jj_nt.kind) {
12991 case 5:
12992 case 16:
12993 case 17:
12994 case REPLACE:
12995 case DEFINER:
12996 case CURRENT_USER:
12997 case LANGUAGE:
12998 case INLINE:
12999 case ADD:
13000 case AGGREGATE:
13001 case ARRAY:
13002 case AT:
13003 case ATTRIBUTE:
13004 case AUTHID:
13005 case BODY:
13006 case BULK:
13007 case BYTE:
13008 case CASCADE:
13009 case CASE:
13010 case CLOSE:
13011 case COALESCE:
13012 case COLLECT:
13013 case COLUMN:
13014 case COMMENT:
13015 case COMMIT:
13016 case CONSTRUCTOR:
13017 case CONTINUE:
13018 case CONVERT:
13019 case CURRENT:
13020 case CURSOR:
13021 case DATA:
13022 case DATE:
13023 case DAY:
13024 case DISABLE:
13025 case EDITIONABLE:
13026 case ELEMENT:
13027 case ENABLE:
13028 case ESCAPE:
13029 case EXCEPT:
13030 case EXCEPTIONS:
13031 case EXIT:
13032 case EXTERNAL:
13033 case EXTENDS:
13034 case EXTRACT:
13035 case FALSE:
13036 case FINAL:
13037 case FORCE:
13038 case FUNCTION:
13039 case GLOBAL:
13040 case HASH:
13041 case HEAP:
13042 case HOUR:
13043 case IMMEDIATE:
13044 case INDICES:
13045 case INDEXTYPE:
13046 case INDICATOR:
13047 case INSTANTIABLE:
13048 case INTERVAL:
13049 case INVALIDATE:
13050 case ISOLATION:
13051 case JAVA:
13052 case LEVEL:
13053 case LIMIT:
13054 case LOOP:
13055 case MAP:
13056 case MAX:
13057 case MEMBER:
13058 case MERGE:
13059 case MIN:
13060 case MINUTE:
13061 case MLSLABEL:
13062 case MODIFY:
13063 case MOD:
13064 case MONTH:
13065 case NATURAL:
13066 case NEW:
13067 case NEW_DOT:
13068 case NO:
13069 case NONEDITIONABLE:
13070 case NOT:
13071 case NULL:
13072 case NULLIF:
13073 case OBJECT:
13074 case OID:
13075 case OPAQUE:
13076 case OPEN:
13077 case OPERATOR:
13078 case ORGANIZATION:
13079 case OTHERS:
13080 case OVERRIDING:
13081 case PACKAGE:
13082 case PARTITION:
13083 case PRESERVE:
13084 case PRIVATE:
13085 case PROCEDURE:
13086 case RANGE:
13087 case RAW:
13088 case REAL:
13089 case RECORD:
13090 case REF:
13091 case RELEASE:
13092 case RELIES_ON:
13093 case RENAME:
13094 case RESULT:
13095 case RETURN:
13096 case RETURNING:
13097 case REVERSE:
13098 case ROLLBACK:
13099 case ROW:
13100 case ROWS:
13101 case ROWID:
13102 case ROWNUM:
13103 case SAVE:
13104 case SAVEPOINT:
13105 case SECOND:
13106 case SELECT:
13107 case SELF:
13108 case SET:
13109 case SPACE:
13110 case SQL:
13111 case SQLCODE:
13112 case SQLERRM:
13113 case STATIC:
13114 case SUBTYPE:
13115 case SUBSTITUTABLE:
13116 case SUCCESSFUL:
13117 case SYSDATE:
13118 case SYS_REFCURSOR:
13119 case TEMPORARY:
13120 case TIME:
13121 case TIMESTAMP:
13122 case TIMEZONE_REGION:
13123 case TIMEZONE_ABBR:
13124 case TIMEZONE_MINUTE:
13125 case TIMEZONE_HOUR:
13126 case TRANSACTION:
13127 case TRUE:
13128 case TYPE:
13129 case UNDER:
13130 case USING:
13131 case YES:
13132 case SHOW:
13133 case A:
13134 case DOUBLE:
13135 case DEC:
13136 case PRECISION:
13137 case INT:
13138 case NUMERIC:
13139 case NCHAR:
13140 case NVARCHAR2:
13141 case STRING:
13142 case UROWID:
13143 case VARRAY:
13144 case VARYING:
13145 case BFILE:
13146 case BLOB:
13147 case CLOB:
13148 case NCLOB:
13149 case YEAR:
13150 case LOCAL:
13151 case WITH:
13152 case ZONE:
13153 case CHARACTER:
13154 case AFTER:
13155 case BEFORE:
13156 case OLD:
13157 case PARENT:
13158 case CC_IF:
13159 case ANALYZE:
13160 case ASSOCIATE:
13161 case AUDIT:
13162 case COMPOUND:
13163 case DATABASE:
13164 case CALL:
13165 case DDL:
13166 case DISASSOCIATE:
13167 case EACH:
13168 case FOLLOWS:
13169 case LOGOFF:
13170 case LOGON:
13171 case NESTED:
13172 case NOAUDIT:
13173 case SCHEMA:
13174 case SERVERERROR:
13175 case SHUTDOWN:
13176 case STARTUP:
13177 case STATEMENT:
13178 case STATISTICS:
13179 case SUSPEND:
13180 case TRUNCATE:
13181 case WRAPPED:
13182 case LIBRARY:
13183 case NAME:
13184 case STRUCT:
13185 case CONTEXT:
13186 case PARAMETERS:
13187 case LENGTH:
13188 case TDO:
13189 case MAXLEN:
13190 case CHARSETID:
13191 case CHARSETFORM:
13192 case ACCEPT:
13193 case ACCESSIBLE:
13194 case COPY:
13195 case DEFINE:
13196 case DISCONNECT:
13197 case HOST:
13198 case PRINT:
13199 case QUIT:
13200 case REMARK:
13201 case UNDEFINE:
13202 case VARIABLE:
13203 case WHENEVER:
13204 case ATTACH:
13205 case CAST:
13206 case TREAT:
13207 case TRIM:
13208 case LEFT:
13209 case RIGHT:
13210 case BOTH:
13211 case EMPTY:
13212 case MULTISET:
13213 case SUBMULTISET:
13214 case LEADING:
13215 case TRAILING:
13216 case CHAR_CS:
13217 case NCHAR_CS:
13218 case DBTIMEZONE:
13219 case SESSIONTIMEZONE:
13220 case AUTHENTICATED:
13221 case LINK:
13222 case SHARED:
13223 case DIRECTORY:
13224 case USER:
13225 case IDENTIFIER:
13226 case UNSIGNED_NUMERIC_LITERAL:
13227 case CHARACTER_LITERAL:
13228 case STRING_LITERAL:
13229 case QUOTED_LITERAL:
13230 Expression();
13231 break;
13232 default:
13233 jj_la1[146] = jj_gen;
13234 ;
13235 }
13236 jjtree.closeNodeScope(jjtn000, true);
13237 jjtc000 = false;
13238 {if (true) return jjtn000 ;}
13239 } catch (Throwable jjte000) {
13240 if (jjtc000) {
13241 jjtree.clearNodeScope(jjtn000);
13242 jjtc000 = false;
13243 } else {
13244 jjtree.popNode();
13245 }
13246 if (jjte000 instanceof RuntimeException) {
13247 {if (true) throw (RuntimeException)jjte000;}
13248 }
13249 if (jjte000 instanceof ParseException) {
13250 {if (true) throw (ParseException)jjte000;}
13251 }
13252 {if (true) throw (Error)jjte000;}
13253 } finally {
13254 if (jjtc000) {
13255 jjtree.closeNodeScope(jjtn000, true);
13256 }
13257 }
13258 throw new Error("Missing return statement in function");
13259 }
13260
13261 final public ASTContinueStatement ContinueStatement() throws ParseException {
13262
13263 ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
13264 boolean jjtc000 = true;
13265 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13266 try {
13267 jj_consume_token(CONTINUE);
13268 switch (jj_nt.kind) {
13269 case REPLACE:
13270 case DEFINER:
13271 case CURRENT_USER:
13272 case LANGUAGE:
13273 case INLINE:
13274 case ADD:
13275 case AGGREGATE:
13276 case ARRAY:
13277 case AT:
13278 case ATTRIBUTE:
13279 case AUTHID:
13280 case BODY:
13281 case BULK:
13282 case BYTE:
13283 case CASCADE:
13284 case CLOSE:
13285 case COALESCE:
13286 case COLLECT:
13287 case COLUMN:
13288 case COMMENT:
13289 case COMMIT:
13290 case CONSTRUCTOR:
13291 case CONTINUE:
13292 case CONVERT:
13293 case CURRENT:
13294 case CURSOR:
13295 case DATA:
13296 case DAY:
13297 case DISABLE:
13298 case EDITIONABLE:
13299 case ELEMENT:
13300 case ENABLE:
13301 case ESCAPE:
13302 case EXCEPT:
13303 case EXCEPTIONS:
13304 case EXIT:
13305 case EXTERNAL:
13306 case EXTENDS:
13307 case EXTRACT:
13308 case FALSE:
13309 case FINAL:
13310 case FORCE:
13311 case FUNCTION:
13312 case GLOBAL:
13313 case HASH:
13314 case HEAP:
13315 case HOUR:
13316 case IMMEDIATE:
13317 case INDICES:
13318 case INDEXTYPE:
13319 case INDICATOR:
13320 case INSTANTIABLE:
13321 case INTERVAL:
13322 case INVALIDATE:
13323 case ISOLATION:
13324 case JAVA:
13325 case LEVEL:
13326 case LIMIT:
13327 case LOOP:
13328 case MAP:
13329 case MAX:
13330 case MEMBER:
13331 case MERGE:
13332 case MIN:
13333 case MINUTE:
13334 case MLSLABEL:
13335 case MODIFY:
13336 case MOD:
13337 case MONTH:
13338 case NATURAL:
13339 case NEW:
13340 case NO:
13341 case NONEDITIONABLE:
13342 case NULLIF:
13343 case OBJECT:
13344 case OID:
13345 case OPAQUE:
13346 case OPEN:
13347 case OPERATOR:
13348 case ORGANIZATION:
13349 case OTHERS:
13350 case OVERRIDING:
13351 case PACKAGE:
13352 case PARTITION:
13353 case PRESERVE:
13354 case PRIVATE:
13355 case PROCEDURE:
13356 case RANGE:
13357 case RAW:
13358 case REAL:
13359 case RECORD:
13360 case REF:
13361 case RELEASE:
13362 case RELIES_ON:
13363 case RENAME:
13364 case RESULT:
13365 case RETURN:
13366 case RETURNING:
13367 case REVERSE:
13368 case ROLLBACK:
13369 case ROW:
13370 case ROWS:
13371 case ROWID:
13372 case ROWNUM:
13373 case SAVE:
13374 case SAVEPOINT:
13375 case SECOND:
13376 case SELF:
13377 case SET:
13378 case SPACE:
13379 case SQL:
13380 case SQLCODE:
13381 case SQLERRM:
13382 case STATIC:
13383 case SUBTYPE:
13384 case SUBSTITUTABLE:
13385 case SUCCESSFUL:
13386 case SYSDATE:
13387 case SYS_REFCURSOR:
13388 case TEMPORARY:
13389 case TIME:
13390 case TIMESTAMP:
13391 case TIMEZONE_REGION:
13392 case TIMEZONE_ABBR:
13393 case TIMEZONE_MINUTE:
13394 case TIMEZONE_HOUR:
13395 case TRANSACTION:
13396 case TRUE:
13397 case TYPE:
13398 case UNDER:
13399 case USING:
13400 case YES:
13401 case SHOW:
13402 case A:
13403 case DOUBLE:
13404 case DEC:
13405 case PRECISION:
13406 case INT:
13407 case NUMERIC:
13408 case NCHAR:
13409 case NVARCHAR2:
13410 case STRING:
13411 case UROWID:
13412 case VARRAY:
13413 case VARYING:
13414 case BFILE:
13415 case BLOB:
13416 case CLOB:
13417 case NCLOB:
13418 case YEAR:
13419 case LOCAL:
13420 case ZONE:
13421 case CHARACTER:
13422 case AFTER:
13423 case BEFORE:
13424 case OLD:
13425 case PARENT:
13426 case ANALYZE:
13427 case ASSOCIATE:
13428 case AUDIT:
13429 case COMPOUND:
13430 case DATABASE:
13431 case CALL:
13432 case DDL:
13433 case DISASSOCIATE:
13434 case EACH:
13435 case FOLLOWS:
13436 case LOGOFF:
13437 case LOGON:
13438 case NESTED:
13439 case NOAUDIT:
13440 case SCHEMA:
13441 case SERVERERROR:
13442 case SHUTDOWN:
13443 case STARTUP:
13444 case STATEMENT:
13445 case STATISTICS:
13446 case SUSPEND:
13447 case TRUNCATE:
13448 case WRAPPED:
13449 case LIBRARY:
13450 case NAME:
13451 case STRUCT:
13452 case CONTEXT:
13453 case PARAMETERS:
13454 case LENGTH:
13455 case TDO:
13456 case MAXLEN:
13457 case CHARSETID:
13458 case CHARSETFORM:
13459 case ACCEPT:
13460 case ACCESSIBLE:
13461 case COPY:
13462 case DEFINE:
13463 case DISCONNECT:
13464 case HOST:
13465 case PRINT:
13466 case QUIT:
13467 case REMARK:
13468 case UNDEFINE:
13469 case VARIABLE:
13470 case WHENEVER:
13471 case ATTACH:
13472 case CAST:
13473 case TREAT:
13474 case TRIM:
13475 case LEFT:
13476 case RIGHT:
13477 case BOTH:
13478 case EMPTY:
13479 case MULTISET:
13480 case SUBMULTISET:
13481 case LEADING:
13482 case TRAILING:
13483 case CHAR_CS:
13484 case NCHAR_CS:
13485 case DBTIMEZONE:
13486 case SESSIONTIMEZONE:
13487 case AUTHENTICATED:
13488 case LINK:
13489 case SHARED:
13490 case DIRECTORY:
13491 case USER:
13492 case IDENTIFIER:
13493 case QUOTED_LITERAL:
13494 label = UnqualifiedID();
13495 break;
13496 default:
13497 jj_la1[147] = jj_gen;
13498 ;
13499 }
13500 switch (jj_nt.kind) {
13501 case WHEN:
13502 jj_consume_token(WHEN);
13503 Expression();
13504 break;
13505 default:
13506 jj_la1[148] = jj_gen;
13507 ;
13508 }
13509 jjtree.closeNodeScope(jjtn000, true);
13510 jjtc000 = false;
13511 if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13512 } catch (Throwable jjte000) {
13513 if (jjtc000) {
13514 jjtree.clearNodeScope(jjtn000);
13515 jjtc000 = false;
13516 } else {
13517 jjtree.popNode();
13518 }
13519 if (jjte000 instanceof RuntimeException) {
13520 {if (true) throw (RuntimeException)jjte000;}
13521 }
13522 if (jjte000 instanceof ParseException) {
13523 {if (true) throw (ParseException)jjte000;}
13524 }
13525 {if (true) throw (Error)jjte000;}
13526 } finally {
13527 if (jjtc000) {
13528 jjtree.closeNodeScope(jjtn000, true);
13529 }
13530 }
13531 throw new Error("Missing return statement in function");
13532 }
13533
13534 final public ASTExitStatement ExitStatement() throws ParseException {
13535
13536 ASTExitStatement jjtn000 = new ASTExitStatement(this, JJTEXITSTATEMENT);
13537 boolean jjtc000 = true;
13538 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13539 try {
13540 jj_consume_token(EXIT);
13541 switch (jj_nt.kind) {
13542 case REPLACE:
13543 case DEFINER:
13544 case CURRENT_USER:
13545 case LANGUAGE:
13546 case INLINE:
13547 case ADD:
13548 case AGGREGATE:
13549 case ARRAY:
13550 case AT:
13551 case ATTRIBUTE:
13552 case AUTHID:
13553 case BODY:
13554 case BULK:
13555 case BYTE:
13556 case CASCADE:
13557 case CLOSE:
13558 case COALESCE:
13559 case COLLECT:
13560 case COLUMN:
13561 case COMMENT:
13562 case COMMIT:
13563 case CONSTRUCTOR:
13564 case CONTINUE:
13565 case CONVERT:
13566 case CURRENT:
13567 case CURSOR:
13568 case DATA:
13569 case DAY:
13570 case DISABLE:
13571 case EDITIONABLE:
13572 case ELEMENT:
13573 case ENABLE:
13574 case ESCAPE:
13575 case EXCEPT:
13576 case EXCEPTIONS:
13577 case EXIT:
13578 case EXTERNAL:
13579 case EXTENDS:
13580 case EXTRACT:
13581 case FALSE:
13582 case FINAL:
13583 case FORCE:
13584 case FUNCTION:
13585 case GLOBAL:
13586 case HASH:
13587 case HEAP:
13588 case HOUR:
13589 case IMMEDIATE:
13590 case INDICES:
13591 case INDEXTYPE:
13592 case INDICATOR:
13593 case INSTANTIABLE:
13594 case INTERVAL:
13595 case INVALIDATE:
13596 case ISOLATION:
13597 case JAVA:
13598 case LEVEL:
13599 case LIMIT:
13600 case LOOP:
13601 case MAP:
13602 case MAX:
13603 case MEMBER:
13604 case MERGE:
13605 case MIN:
13606 case MINUTE:
13607 case MLSLABEL:
13608 case MODIFY:
13609 case MOD:
13610 case MONTH:
13611 case NATURAL:
13612 case NEW:
13613 case NO:
13614 case NONEDITIONABLE:
13615 case NULLIF:
13616 case OBJECT:
13617 case OID:
13618 case OPAQUE:
13619 case OPEN:
13620 case OPERATOR:
13621 case ORGANIZATION:
13622 case OTHERS:
13623 case OVERRIDING:
13624 case PACKAGE:
13625 case PARTITION:
13626 case PRESERVE:
13627 case PRIVATE:
13628 case PROCEDURE:
13629 case RANGE:
13630 case RAW:
13631 case REAL:
13632 case RECORD:
13633 case REF:
13634 case RELEASE:
13635 case RELIES_ON:
13636 case RENAME:
13637 case RESULT:
13638 case RETURN:
13639 case RETURNING:
13640 case REVERSE:
13641 case ROLLBACK:
13642 case ROW:
13643 case ROWS:
13644 case ROWID:
13645 case ROWNUM:
13646 case SAVE:
13647 case SAVEPOINT:
13648 case SECOND:
13649 case SELF:
13650 case SET:
13651 case SPACE:
13652 case SQL:
13653 case SQLCODE:
13654 case SQLERRM:
13655 case STATIC:
13656 case SUBTYPE:
13657 case SUBSTITUTABLE:
13658 case SUCCESSFUL:
13659 case SYSDATE:
13660 case SYS_REFCURSOR:
13661 case TEMPORARY:
13662 case TIME:
13663 case TIMESTAMP:
13664 case TIMEZONE_REGION:
13665 case TIMEZONE_ABBR:
13666 case TIMEZONE_MINUTE:
13667 case TIMEZONE_HOUR:
13668 case TRANSACTION:
13669 case TRUE:
13670 case TYPE:
13671 case UNDER:
13672 case USING:
13673 case YES:
13674 case SHOW:
13675 case A:
13676 case DOUBLE:
13677 case DEC:
13678 case PRECISION:
13679 case INT:
13680 case NUMERIC:
13681 case NCHAR:
13682 case NVARCHAR2:
13683 case STRING:
13684 case UROWID:
13685 case VARRAY:
13686 case VARYING:
13687 case BFILE:
13688 case BLOB:
13689 case CLOB:
13690 case NCLOB:
13691 case YEAR:
13692 case LOCAL:
13693 case ZONE:
13694 case CHARACTER:
13695 case AFTER:
13696 case BEFORE:
13697 case OLD:
13698 case PARENT:
13699 case ANALYZE:
13700 case ASSOCIATE:
13701 case AUDIT:
13702 case COMPOUND:
13703 case DATABASE:
13704 case CALL:
13705 case DDL:
13706 case DISASSOCIATE:
13707 case EACH:
13708 case FOLLOWS:
13709 case LOGOFF:
13710 case LOGON:
13711 case NESTED:
13712 case NOAUDIT:
13713 case SCHEMA:
13714 case SERVERERROR:
13715 case SHUTDOWN:
13716 case STARTUP:
13717 case STATEMENT:
13718 case STATISTICS:
13719 case SUSPEND:
13720 case TRUNCATE:
13721 case WRAPPED:
13722 case LIBRARY:
13723 case NAME:
13724 case STRUCT:
13725 case CONTEXT:
13726 case PARAMETERS:
13727 case LENGTH:
13728 case TDO:
13729 case MAXLEN:
13730 case CHARSETID:
13731 case CHARSETFORM:
13732 case ACCEPT:
13733 case ACCESSIBLE:
13734 case COPY:
13735 case DEFINE:
13736 case DISCONNECT:
13737 case HOST:
13738 case PRINT:
13739 case QUIT:
13740 case REMARK:
13741 case UNDEFINE:
13742 case VARIABLE:
13743 case WHENEVER:
13744 case ATTACH:
13745 case CAST:
13746 case TREAT:
13747 case TRIM:
13748 case LEFT:
13749 case RIGHT:
13750 case BOTH:
13751 case EMPTY:
13752 case MULTISET:
13753 case SUBMULTISET:
13754 case LEADING:
13755 case TRAILING:
13756 case CHAR_CS:
13757 case NCHAR_CS:
13758 case DBTIMEZONE:
13759 case SESSIONTIMEZONE:
13760 case AUTHENTICATED:
13761 case LINK:
13762 case SHARED:
13763 case DIRECTORY:
13764 case USER:
13765 case IDENTIFIER:
13766 case QUOTED_LITERAL:
13767 label = UnqualifiedID();
13768 break;
13769 default:
13770 jj_la1[149] = jj_gen;
13771 ;
13772 }
13773 switch (jj_nt.kind) {
13774 case WHEN:
13775 jj_consume_token(WHEN);
13776 Expression();
13777 break;
13778 default:
13779 jj_la1[150] = jj_gen;
13780 ;
13781 }
13782 jjtree.closeNodeScope(jjtn000, true);
13783 jjtc000 = false;
13784 if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13785 } catch (Throwable jjte000) {
13786 if (jjtc000) {
13787 jjtree.clearNodeScope(jjtn000);
13788 jjtc000 = false;
13789 } else {
13790 jjtree.popNode();
13791 }
13792 if (jjte000 instanceof RuntimeException) {
13793 {if (true) throw (RuntimeException)jjte000;}
13794 }
13795 if (jjte000 instanceof ParseException) {
13796 {if (true) throw (ParseException)jjte000;}
13797 }
13798 {if (true) throw (Error)jjte000;}
13799 } finally {
13800 if (jjtc000) {
13801 jjtree.closeNodeScope(jjtn000, true);
13802 }
13803 }
13804 throw new Error("Missing return statement in function");
13805 }
13806
13807 final public ASTRaiseStatement RaiseStatement() throws ParseException {
13808
13809 ASTRaiseStatement jjtn000 = new ASTRaiseStatement(this, JJTRAISESTATEMENT);
13810 boolean jjtc000 = true;
13811 jjtree.openNodeScope(jjtn000);PLSQLNode exception = null ;
13812 try {
13813 jj_consume_token(RAISE);
13814 switch (jj_nt.kind) {
13815 case REPLACE:
13816 case DEFINER:
13817 case CURRENT_USER:
13818 case LANGUAGE:
13819 case INLINE:
13820 case ADD:
13821 case AGGREGATE:
13822 case ARRAY:
13823 case AT:
13824 case ATTRIBUTE:
13825 case AUTHID:
13826 case BODY:
13827 case BULK:
13828 case BYTE:
13829 case CASCADE:
13830 case CLOSE:
13831 case COALESCE:
13832 case COLLECT:
13833 case COLUMN:
13834 case COMMENT:
13835 case COMMIT:
13836 case CONSTRUCTOR:
13837 case CONTINUE:
13838 case CONVERT:
13839 case CURRENT:
13840 case CURSOR:
13841 case DATA:
13842 case DAY:
13843 case DISABLE:
13844 case EDITIONABLE:
13845 case ELEMENT:
13846 case ENABLE:
13847 case ESCAPE:
13848 case EXCEPT:
13849 case EXCEPTIONS:
13850 case EXIT:
13851 case EXTERNAL:
13852 case EXTENDS:
13853 case EXTRACT:
13854 case FALSE:
13855 case FINAL:
13856 case FORCE:
13857 case FUNCTION:
13858 case GLOBAL:
13859 case HASH:
13860 case HEAP:
13861 case HOUR:
13862 case IMMEDIATE:
13863 case INDICES:
13864 case INDEXTYPE:
13865 case INDICATOR:
13866 case INSTANTIABLE:
13867 case INTERVAL:
13868 case INVALIDATE:
13869 case ISOLATION:
13870 case JAVA:
13871 case LEVEL:
13872 case LIMIT:
13873 case LOOP:
13874 case MAP:
13875 case MAX:
13876 case MEMBER:
13877 case MERGE:
13878 case MIN:
13879 case MINUTE:
13880 case MLSLABEL:
13881 case MODIFY:
13882 case MOD:
13883 case MONTH:
13884 case NATURAL:
13885 case NEW:
13886 case NO:
13887 case NONEDITIONABLE:
13888 case NULLIF:
13889 case OBJECT:
13890 case OID:
13891 case OPAQUE:
13892 case OPEN:
13893 case OPERATOR:
13894 case ORGANIZATION:
13895 case OTHERS:
13896 case OVERRIDING:
13897 case PACKAGE:
13898 case PARTITION:
13899 case PRESERVE:
13900 case PRIVATE:
13901 case PROCEDURE:
13902 case RANGE:
13903 case RAW:
13904 case REAL:
13905 case RECORD:
13906 case REF:
13907 case RELEASE:
13908 case RELIES_ON:
13909 case RENAME:
13910 case RESULT:
13911 case RETURN:
13912 case RETURNING:
13913 case REVERSE:
13914 case ROLLBACK:
13915 case ROW:
13916 case ROWS:
13917 case ROWID:
13918 case ROWNUM:
13919 case SAVE:
13920 case SAVEPOINT:
13921 case SECOND:
13922 case SELF:
13923 case SET:
13924 case SPACE:
13925 case SQL:
13926 case SQLCODE:
13927 case SQLERRM:
13928 case STATIC:
13929 case SUBTYPE:
13930 case SUBSTITUTABLE:
13931 case SUCCESSFUL:
13932 case SYSDATE:
13933 case SYS_REFCURSOR:
13934 case TEMPORARY:
13935 case TIME:
13936 case TIMESTAMP:
13937 case TIMEZONE_REGION:
13938 case TIMEZONE_ABBR:
13939 case TIMEZONE_MINUTE:
13940 case TIMEZONE_HOUR:
13941 case TRANSACTION:
13942 case TRUE:
13943 case TYPE:
13944 case UNDER:
13945 case USING:
13946 case YES:
13947 case SHOW:
13948 case A:
13949 case DOUBLE:
13950 case DEC:
13951 case PRECISION:
13952 case INT:
13953 case NUMERIC:
13954 case NCHAR:
13955 case NVARCHAR2:
13956 case STRING:
13957 case UROWID:
13958 case VARRAY:
13959 case VARYING:
13960 case BFILE:
13961 case BLOB:
13962 case CLOB:
13963 case NCLOB:
13964 case YEAR:
13965 case LOCAL:
13966 case ZONE:
13967 case CHARACTER:
13968 case AFTER:
13969 case BEFORE:
13970 case OLD:
13971 case PARENT:
13972 case ANALYZE:
13973 case ASSOCIATE:
13974 case AUDIT:
13975 case COMPOUND:
13976 case DATABASE:
13977 case CALL:
13978 case DDL:
13979 case DISASSOCIATE:
13980 case EACH:
13981 case FOLLOWS:
13982 case LOGOFF:
13983 case LOGON:
13984 case NESTED:
13985 case NOAUDIT:
13986 case SCHEMA:
13987 case SERVERERROR:
13988 case SHUTDOWN:
13989 case STARTUP:
13990 case STATEMENT:
13991 case STATISTICS:
13992 case SUSPEND:
13993 case TRUNCATE:
13994 case WRAPPED:
13995 case LIBRARY:
13996 case NAME:
13997 case STRUCT:
13998 case CONTEXT:
13999 case PARAMETERS:
14000 case LENGTH:
14001 case TDO:
14002 case MAXLEN:
14003 case CHARSETID:
14004 case CHARSETFORM:
14005 case ACCEPT:
14006 case ACCESSIBLE:
14007 case COPY:
14008 case DEFINE:
14009 case DISCONNECT:
14010 case HOST:
14011 case PRINT:
14012 case QUIT:
14013 case REMARK:
14014 case UNDEFINE:
14015 case VARIABLE:
14016 case WHENEVER:
14017 case ATTACH:
14018 case CAST:
14019 case TREAT:
14020 case TRIM:
14021 case LEFT:
14022 case RIGHT:
14023 case BOTH:
14024 case EMPTY:
14025 case MULTISET:
14026 case SUBMULTISET:
14027 case LEADING:
14028 case TRAILING:
14029 case CHAR_CS:
14030 case NCHAR_CS:
14031 case DBTIMEZONE:
14032 case SESSIONTIMEZONE:
14033 case AUTHENTICATED:
14034 case LINK:
14035 case SHARED:
14036 case DIRECTORY:
14037 case USER:
14038 case IDENTIFIER:
14039 case QUOTED_LITERAL:
14040 exception = QualifiedName();
14041 break;
14042 default:
14043 jj_la1[151] = jj_gen;
14044 ;
14045 }
14046 jjtree.closeNodeScope(jjtn000, true);
14047 jjtc000 = false;
14048 if (null != exception) { jjtn000.setImage(exception.getImage()) ; } {if (true) return jjtn000 ;}
14049 } catch (Throwable jjte000) {
14050 if (jjtc000) {
14051 jjtree.clearNodeScope(jjtn000);
14052 jjtc000 = false;
14053 } else {
14054 jjtree.popNode();
14055 }
14056 if (jjte000 instanceof RuntimeException) {
14057 {if (true) throw (RuntimeException)jjte000;}
14058 }
14059 if (jjte000 instanceof ParseException) {
14060 {if (true) throw (ParseException)jjte000;}
14061 }
14062 {if (true) throw (Error)jjte000;}
14063 } finally {
14064 if (jjtc000) {
14065 jjtree.closeNodeScope(jjtn000, true);
14066 }
14067 }
14068 throw new Error("Missing return statement in function");
14069 }
14070
14071 final public ASTCloseStatement CloseStatement() throws ParseException {
14072
14073 ASTCloseStatement jjtn000 = new ASTCloseStatement(this, JJTCLOSESTATEMENT);
14074 boolean jjtc000 = true;
14075 jjtree.openNodeScope(jjtn000);PLSQLNode cursor = null ;
14076 try {
14077 jj_consume_token(CLOSE);
14078 cursor = QualifiedName();
14079 jjtree.closeNodeScope(jjtn000, true);
14080 jjtc000 = false;
14081 jjtn000.setImage(cursor.getImage()) ; {if (true) return jjtn000 ;}
14082 } catch (Throwable jjte000) {
14083 if (jjtc000) {
14084 jjtree.clearNodeScope(jjtn000);
14085 jjtc000 = false;
14086 } else {
14087 jjtree.popNode();
14088 }
14089 if (jjte000 instanceof RuntimeException) {
14090 {if (true) throw (RuntimeException)jjte000;}
14091 }
14092 if (jjte000 instanceof ParseException) {
14093 {if (true) throw (ParseException)jjte000;}
14094 }
14095 {if (true) throw (Error)jjte000;}
14096 } finally {
14097 if (jjtc000) {
14098 jjtree.closeNodeScope(jjtn000, true);
14099 }
14100 }
14101 throw new Error("Missing return statement in function");
14102 }
14103
14104 final public ASTOpenStatement OpenStatement() throws ParseException {
14105
14106 ASTOpenStatement jjtn000 = new ASTOpenStatement(this, JJTOPENSTATEMENT);
14107 boolean jjtc000 = true;
14108 jjtree.openNodeScope(jjtn000);
14109 try {
14110 jj_consume_token(OPEN);
14111 switch (jj_nt.kind) {
14112 case 5:
14113 case 16:
14114 case 17:
14115 case REPLACE:
14116 case DEFINER:
14117 case CURRENT_USER:
14118 case LANGUAGE:
14119 case INLINE:
14120 case ADD:
14121 case AGGREGATE:
14122 case ARRAY:
14123 case AT:
14124 case ATTRIBUTE:
14125 case AUTHID:
14126 case BODY:
14127 case BULK:
14128 case BYTE:
14129 case CASCADE:
14130 case CASE:
14131 case CLOSE:
14132 case COALESCE:
14133 case COLLECT:
14134 case COLUMN:
14135 case COMMENT:
14136 case COMMIT:
14137 case CONSTRUCTOR:
14138 case CONTINUE:
14139 case CONVERT:
14140 case CURRENT:
14141 case CURSOR:
14142 case DATA:
14143 case DATE:
14144 case DAY:
14145 case DISABLE:
14146 case EDITIONABLE:
14147 case ELEMENT:
14148 case ENABLE:
14149 case ESCAPE:
14150 case EXCEPT:
14151 case EXCEPTIONS:
14152 case EXIT:
14153 case EXTERNAL:
14154 case EXTENDS:
14155 case EXTRACT:
14156 case FALSE:
14157 case FINAL:
14158 case FORCE:
14159 case FUNCTION:
14160 case GLOBAL:
14161 case HASH:
14162 case HEAP:
14163 case HOUR:
14164 case IMMEDIATE:
14165 case INDICES:
14166 case INDEXTYPE:
14167 case INDICATOR:
14168 case INSTANTIABLE:
14169 case INTERVAL:
14170 case INVALIDATE:
14171 case ISOLATION:
14172 case JAVA:
14173 case LEVEL:
14174 case LIMIT:
14175 case LOOP:
14176 case MAP:
14177 case MAX:
14178 case MEMBER:
14179 case MERGE:
14180 case MIN:
14181 case MINUTE:
14182 case MLSLABEL:
14183 case MODIFY:
14184 case MOD:
14185 case MONTH:
14186 case NATURAL:
14187 case NEW:
14188 case NEW_DOT:
14189 case NO:
14190 case NONEDITIONABLE:
14191 case NOT:
14192 case NULL:
14193 case NULLIF:
14194 case OBJECT:
14195 case OID:
14196 case OPAQUE:
14197 case OPEN:
14198 case OPERATOR:
14199 case ORGANIZATION:
14200 case OTHERS:
14201 case OVERRIDING:
14202 case PACKAGE:
14203 case PARTITION:
14204 case PRESERVE:
14205 case PRIVATE:
14206 case PROCEDURE:
14207 case RANGE:
14208 case RAW:
14209 case REAL:
14210 case RECORD:
14211 case REF:
14212 case RELEASE:
14213 case RELIES_ON:
14214 case RENAME:
14215 case RESULT:
14216 case RETURN:
14217 case RETURNING:
14218 case REVERSE:
14219 case ROLLBACK:
14220 case ROW:
14221 case ROWS:
14222 case ROWID:
14223 case ROWNUM:
14224 case SAVE:
14225 case SAVEPOINT:
14226 case SECOND:
14227 case SELECT:
14228 case SELF:
14229 case SET:
14230 case SPACE:
14231 case SQL:
14232 case SQLCODE:
14233 case SQLERRM:
14234 case STATIC:
14235 case SUBTYPE:
14236 case SUBSTITUTABLE:
14237 case SUCCESSFUL:
14238 case SYSDATE:
14239 case SYS_REFCURSOR:
14240 case TEMPORARY:
14241 case TIME:
14242 case TIMESTAMP:
14243 case TIMEZONE_REGION:
14244 case TIMEZONE_ABBR:
14245 case TIMEZONE_MINUTE:
14246 case TIMEZONE_HOUR:
14247 case TRANSACTION:
14248 case TRUE:
14249 case TYPE:
14250 case UNDER:
14251 case USING:
14252 case YES:
14253 case SHOW:
14254 case A:
14255 case DOUBLE:
14256 case DEC:
14257 case PRECISION:
14258 case INT:
14259 case NUMERIC:
14260 case NCHAR:
14261 case NVARCHAR2:
14262 case STRING:
14263 case UROWID:
14264 case VARRAY:
14265 case VARYING:
14266 case BFILE:
14267 case BLOB:
14268 case CLOB:
14269 case NCLOB:
14270 case YEAR:
14271 case LOCAL:
14272 case WITH:
14273 case ZONE:
14274 case CHARACTER:
14275 case AFTER:
14276 case BEFORE:
14277 case OLD:
14278 case PARENT:
14279 case CC_IF:
14280 case ANALYZE:
14281 case ASSOCIATE:
14282 case AUDIT:
14283 case COMPOUND:
14284 case DATABASE:
14285 case CALL:
14286 case DDL:
14287 case DISASSOCIATE:
14288 case EACH:
14289 case FOLLOWS:
14290 case LOGOFF:
14291 case LOGON:
14292 case NESTED:
14293 case NOAUDIT:
14294 case SCHEMA:
14295 case SERVERERROR:
14296 case SHUTDOWN:
14297 case STARTUP:
14298 case STATEMENT:
14299 case STATISTICS:
14300 case SUSPEND:
14301 case TRUNCATE:
14302 case WRAPPED:
14303 case LIBRARY:
14304 case NAME:
14305 case STRUCT:
14306 case CONTEXT:
14307 case PARAMETERS:
14308 case LENGTH:
14309 case TDO:
14310 case MAXLEN:
14311 case CHARSETID:
14312 case CHARSETFORM:
14313 case ACCEPT:
14314 case ACCESSIBLE:
14315 case COPY:
14316 case DEFINE:
14317 case DISCONNECT:
14318 case HOST:
14319 case PRINT:
14320 case QUIT:
14321 case REMARK:
14322 case UNDEFINE:
14323 case VARIABLE:
14324 case WHENEVER:
14325 case ATTACH:
14326 case CAST:
14327 case TREAT:
14328 case TRIM:
14329 case LEFT:
14330 case RIGHT:
14331 case BOTH:
14332 case EMPTY:
14333 case MULTISET:
14334 case SUBMULTISET:
14335 case LEADING:
14336 case TRAILING:
14337 case CHAR_CS:
14338 case NCHAR_CS:
14339 case DBTIMEZONE:
14340 case SESSIONTIMEZONE:
14341 case AUTHENTICATED:
14342 case LINK:
14343 case SHARED:
14344 case DIRECTORY:
14345 case USER:
14346 case IDENTIFIER:
14347 case UNSIGNED_NUMERIC_LITERAL:
14348 case CHARACTER_LITERAL:
14349 case STRING_LITERAL:
14350 case QUOTED_LITERAL:
14351 Expression();
14352 break;
14353 default:
14354 jj_la1[152] = jj_gen;
14355 ;
14356 }
14357 switch (jj_nt.kind) {
14358 case FOR:
14359 jj_consume_token(FOR);
14360 Expression();
14361 switch (jj_nt.kind) {
14362 case USING:
14363 jj_consume_token(USING);
14364 switch (jj_nt.kind) {
14365 case IN:
14366 case IN_OUT:
14367 case OUT:
14368 switch (jj_nt.kind) {
14369 case IN:
14370 jj_consume_token(IN);
14371 break;
14372 case OUT:
14373 jj_consume_token(OUT);
14374 break;
14375 case IN_OUT:
14376 jj_consume_token(IN_OUT);
14377 break;
14378 default:
14379 jj_la1[153] = jj_gen;
14380 jj_consume_token(-1);
14381 throw new ParseException();
14382 }
14383 break;
14384 default:
14385 jj_la1[154] = jj_gen;
14386 ;
14387 }
14388 Expression();
14389 label_34:
14390 while (true) {
14391 switch (jj_nt.kind) {
14392 case 6:
14393 ;
14394 break;
14395 default:
14396 jj_la1[155] = jj_gen;
14397 break label_34;
14398 }
14399 jj_consume_token(6);
14400 switch (jj_nt.kind) {
14401 case IN:
14402 case IN_OUT:
14403 case OUT:
14404 switch (jj_nt.kind) {
14405 case IN:
14406 jj_consume_token(IN);
14407 break;
14408 case OUT:
14409 jj_consume_token(OUT);
14410 break;
14411 case IN_OUT:
14412 jj_consume_token(IN_OUT);
14413 break;
14414 default:
14415 jj_la1[156] = jj_gen;
14416 jj_consume_token(-1);
14417 throw new ParseException();
14418 }
14419 break;
14420 default:
14421 jj_la1[157] = jj_gen;
14422 ;
14423 }
14424 Expression();
14425 }
14426 break;
14427 default:
14428 jj_la1[158] = jj_gen;
14429 ;
14430 }
14431 break;
14432 default:
14433 jj_la1[159] = jj_gen;
14434 ;
14435 }
14436 jjtree.closeNodeScope(jjtn000, true);
14437 jjtc000 = false;
14438 {if (true) return jjtn000 ;}
14439 } catch (Throwable jjte000) {
14440 if (jjtc000) {
14441 jjtree.clearNodeScope(jjtn000);
14442 jjtc000 = false;
14443 } else {
14444 jjtree.popNode();
14445 }
14446 if (jjte000 instanceof RuntimeException) {
14447 {if (true) throw (RuntimeException)jjte000;}
14448 }
14449 if (jjte000 instanceof ParseException) {
14450 {if (true) throw (ParseException)jjte000;}
14451 }
14452 {if (true) throw (Error)jjte000;}
14453 } finally {
14454 if (jjtc000) {
14455 jjtree.closeNodeScope(jjtn000, true);
14456 }
14457 }
14458 throw new Error("Missing return statement in function");
14459 }
14460
14461 final public ASTFetchStatement FetchStatement() throws ParseException {
14462
14463 ASTFetchStatement jjtn000 = new ASTFetchStatement(this, JJTFETCHSTATEMENT);
14464 boolean jjtc000 = true;
14465 jjtree.openNodeScope(jjtn000);
14466 try {
14467 jj_consume_token(FETCH);
14468 QualifiedName();
14469 switch (jj_nt.kind) {
14470 case BULK:
14471 jj_consume_token(BULK);
14472 jj_consume_token(COLLECT);
14473 break;
14474 default:
14475 jj_la1[160] = jj_gen;
14476 ;
14477 }
14478 jj_consume_token(INTO);
14479 Expression();
14480 label_35:
14481 while (true) {
14482 switch (jj_nt.kind) {
14483 case 6:
14484 ;
14485 break;
14486 default:
14487 jj_la1[161] = jj_gen;
14488 break label_35;
14489 }
14490 jj_consume_token(6);
14491 Expression();
14492 }
14493 switch (jj_nt.kind) {
14494 case LIMIT:
14495 jj_consume_token(LIMIT);
14496 Expression();
14497 break;
14498 default:
14499 jj_la1[162] = jj_gen;
14500 ;
14501 }
14502 jjtree.closeNodeScope(jjtn000, true);
14503 jjtc000 = false;
14504 {if (true) return jjtn000 ;}
14505 } catch (Throwable jjte000) {
14506 if (jjtc000) {
14507 jjtree.clearNodeScope(jjtn000);
14508 jjtc000 = false;
14509 } else {
14510 jjtree.popNode();
14511 }
14512 if (jjte000 instanceof RuntimeException) {
14513 {if (true) throw (RuntimeException)jjte000;}
14514 }
14515 if (jjte000 instanceof ParseException) {
14516 {if (true) throw (ParseException)jjte000;}
14517 }
14518 {if (true) throw (Error)jjte000;}
14519 } finally {
14520 if (jjtc000) {
14521 jjtree.closeNodeScope(jjtn000, true);
14522 }
14523 }
14524 throw new Error("Missing return statement in function");
14525 }
14526
14527 final public ASTEmbeddedSqlStatement EmbeddedSqlStatement() throws ParseException {
14528
14529 ASTEmbeddedSqlStatement jjtn000 = new ASTEmbeddedSqlStatement(this, JJTEMBEDDEDSQLSTATEMENT);
14530 boolean jjtc000 = true;
14531 jjtree.openNodeScope(jjtn000);
14532 try {
14533 jj_consume_token(EXECUTE);
14534 jj_consume_token(IMMEDIATE);
14535 Expression();
14536 switch (jj_nt.kind) {
14537 case INTO:
14538 jj_consume_token(INTO);
14539 Name();
14540 label_36:
14541 while (true) {
14542 switch (jj_nt.kind) {
14543 case 6:
14544 ;
14545 break;
14546 default:
14547 jj_la1[163] = jj_gen;
14548 break label_36;
14549 }
14550 jj_consume_token(6);
14551 Name();
14552 }
14553 break;
14554 default:
14555 jj_la1[164] = jj_gen;
14556 ;
14557 }
14558 switch (jj_nt.kind) {
14559 case USING:
14560 jj_consume_token(USING);
14561 switch (jj_nt.kind) {
14562 case IN:
14563 case OUT:
14564 switch (jj_nt.kind) {
14565 case IN:
14566 jj_consume_token(IN);
14567 switch (jj_nt.kind) {
14568 case OUT:
14569 jj_consume_token(OUT);
14570 break;
14571 default:
14572 jj_la1[165] = jj_gen;
14573 ;
14574 }
14575 break;
14576 case OUT:
14577 jj_consume_token(OUT);
14578 break;
14579 default:
14580 jj_la1[166] = jj_gen;
14581 jj_consume_token(-1);
14582 throw new ParseException();
14583 }
14584 break;
14585 default:
14586 jj_la1[167] = jj_gen;
14587 ;
14588 }
14589 Expression();
14590 label_37:
14591 while (true) {
14592 switch (jj_nt.kind) {
14593 case 6:
14594 ;
14595 break;
14596 default:
14597 jj_la1[168] = jj_gen;
14598 break label_37;
14599 }
14600 jj_consume_token(6);
14601 switch (jj_nt.kind) {
14602 case IN:
14603 case OUT:
14604 switch (jj_nt.kind) {
14605 case IN:
14606 jj_consume_token(IN);
14607 switch (jj_nt.kind) {
14608 case OUT:
14609 jj_consume_token(OUT);
14610 break;
14611 default:
14612 jj_la1[169] = jj_gen;
14613 ;
14614 }
14615 break;
14616 case OUT:
14617 jj_consume_token(OUT);
14618 break;
14619 default:
14620 jj_la1[170] = jj_gen;
14621 jj_consume_token(-1);
14622 throw new ParseException();
14623 }
14624 break;
14625 default:
14626 jj_la1[171] = jj_gen;
14627 ;
14628 }
14629 Expression();
14630 }
14631 break;
14632 default:
14633 jj_la1[172] = jj_gen;
14634 ;
14635 }
14636 switch (jj_nt.kind) {
14637 case RETURN:
14638 case RETURNING:
14639 switch (jj_nt.kind) {
14640 case RETURN:
14641 jj_consume_token(RETURN);
14642 break;
14643 case RETURNING:
14644 jj_consume_token(RETURNING);
14645 break;
14646 default:
14647 jj_la1[173] = jj_gen;
14648 jj_consume_token(-1);
14649 throw new ParseException();
14650 }
14651 jj_consume_token(INTO);
14652 Expression();
14653 label_38:
14654 while (true) {
14655 switch (jj_nt.kind) {
14656 case 6:
14657 ;
14658 break;
14659 default:
14660 jj_la1[174] = jj_gen;
14661 break label_38;
14662 }
14663 jj_consume_token(6);
14664 Expression();
14665 }
14666 break;
14667 default:
14668 jj_la1[175] = jj_gen;
14669 ;
14670 }
14671 jj_consume_token(4);
14672 jjtree.closeNodeScope(jjtn000, true);
14673 jjtc000 = false;
14674 {if (true) return jjtn000 ;}
14675 } catch (Throwable jjte000) {
14676 if (jjtc000) {
14677 jjtree.clearNodeScope(jjtn000);
14678 jjtc000 = false;
14679 } else {
14680 jjtree.popNode();
14681 }
14682 if (jjte000 instanceof RuntimeException) {
14683 {if (true) throw (RuntimeException)jjte000;}
14684 }
14685 if (jjte000 instanceof ParseException) {
14686 {if (true) throw (ParseException)jjte000;}
14687 }
14688 {if (true) throw (Error)jjte000;}
14689 } finally {
14690 if (jjtc000) {
14691 jjtree.closeNodeScope(jjtn000, true);
14692 }
14693 }
14694 throw new Error("Missing return statement in function");
14695 }
14696
14697 final public ASTPipelineStatement PipelineStatement() throws ParseException {
14698
14699 ASTPipelineStatement jjtn000 = new ASTPipelineStatement(this, JJTPIPELINESTATEMENT);
14700 boolean jjtc000 = true;
14701 jjtree.openNodeScope(jjtn000);
14702 try {
14703 jj_consume_token(PIPE);
14704 jj_consume_token(ROW);
14705 Expression();
14706 jjtree.closeNodeScope(jjtn000, true);
14707 jjtc000 = false;
14708 {if (true) return jjtn000 ;}
14709 } catch (Throwable jjte000) {
14710 if (jjtc000) {
14711 jjtree.clearNodeScope(jjtn000);
14712 jjtc000 = false;
14713 } else {
14714 jjtree.popNode();
14715 }
14716 if (jjte000 instanceof RuntimeException) {
14717 {if (true) throw (RuntimeException)jjte000;}
14718 }
14719 if (jjte000 instanceof ParseException) {
14720 {if (true) throw (ParseException)jjte000;}
14721 }
14722 {if (true) throw (Error)jjte000;}
14723 } finally {
14724 if (jjtc000) {
14725 jjtree.closeNodeScope(jjtn000, true);
14726 }
14727 }
14728 throw new Error("Missing return statement in function");
14729 }
14730
14731 final public ASTConditionalCompilationStatement ConditionalCompilationStatement() throws ParseException {
14732
14733 ASTConditionalCompilationStatement jjtn000 = new ASTConditionalCompilationStatement(this, JJTCONDITIONALCOMPILATIONSTATEMENT);
14734 boolean jjtc000 = true;
14735 jjtree.openNodeScope(jjtn000);
14736 try {
14737 switch (jj_nt.kind) {
14738 case CC_IF:
14739 jj_consume_token(CC_IF);
14740 ConditionalOrExpression();
14741 jj_consume_token(CC_THEN);
14742 label_39:
14743 while (true) {
14744 switch (jj_nt.kind) {
14745 case 5:
14746 case 16:
14747 case 17:
14748 case 21:
14749 case REPLACE:
14750 case DEFINER:
14751 case CURRENT_USER:
14752 case LANGUAGE:
14753 case INLINE:
14754 case ADD:
14755 case AGGREGATE:
14756 case ARRAY:
14757 case AT:
14758 case ATTRIBUTE:
14759 case AUTHID:
14760 case BEGIN:
14761 case BODY:
14762 case BULK:
14763 case BYTE:
14764 case CASCADE:
14765 case CASE:
14766 case CLOSE:
14767 case COALESCE:
14768 case COLLECT:
14769 case COLUMN:
14770 case COMMENT:
14771 case COMMIT:
14772 case CONSTRUCTOR:
14773 case CONTINUE:
14774 case CONVERT:
14775 case CURRENT:
14776 case CURSOR:
14777 case DATA:
14778 case DATE:
14779 case DAY:
14780 case DECLARE:
14781 case DELETE:
14782 case DISABLE:
14783 case EDITIONABLE:
14784 case ELEMENT:
14785 case ENABLE:
14786 case ESCAPE:
14787 case EXCEPT:
14788 case EXCEPTIONS:
14789 case EXECUTE:
14790 case EXIT:
14791 case EXTERNAL:
14792 case EXTENDS:
14793 case EXTRACT:
14794 case FALSE:
14795 case FETCH:
14796 case FINAL:
14797 case FOR:
14798 case FORALL:
14799 case FORCE:
14800 case FUNCTION:
14801 case GLOBAL:
14802 case GOTO:
14803 case HASH:
14804 case HEAP:
14805 case HOUR:
14806 case IF:
14807 case IMMEDIATE:
14808 case INDICES:
14809 case INDEXTYPE:
14810 case INDICATOR:
14811 case INSERT:
14812 case INSTANTIABLE:
14813 case INTERVAL:
14814 case INVALIDATE:
14815 case ISOLATION:
14816 case JAVA:
14817 case LEVEL:
14818 case LIMIT:
14819 case LOCK:
14820 case LOOP:
14821 case MAP:
14822 case MAX:
14823 case MEMBER:
14824 case MERGE:
14825 case MIN:
14826 case MINUTE:
14827 case MLSLABEL:
14828 case MODIFY:
14829 case MOD:
14830 case MONTH:
14831 case NATURAL:
14832 case NEW:
14833 case NEW_DOT:
14834 case NO:
14835 case NONEDITIONABLE:
14836 case NOT:
14837 case NULL:
14838 case NULLIF:
14839 case OBJECT:
14840 case OID:
14841 case OPAQUE:
14842 case OPEN:
14843 case OPERATOR:
14844 case ORGANIZATION:
14845 case OTHERS:
14846 case OVERRIDING:
14847 case PACKAGE:
14848 case PARTITION:
14849 case PIPE:
14850 case PRAGMA:
14851 case PRESERVE:
14852 case PRIVATE:
14853 case PROCEDURE:
14854 case RAISE:
14855 case RANGE:
14856 case RAW:
14857 case REAL:
14858 case RECORD:
14859 case REF:
14860 case RELEASE:
14861 case RELIES_ON:
14862 case RENAME:
14863 case RESULT:
14864 case RETURN:
14865 case RETURNING:
14866 case REVERSE:
14867 case ROLLBACK:
14868 case ROW:
14869 case ROWS:
14870 case ROWID:
14871 case ROWNUM:
14872 case SAVE:
14873 case SAVEPOINT:
14874 case SECOND:
14875 case SELECT:
14876 case SELF:
14877 case SET:
14878 case SPACE:
14879 case SQL:
14880 case SQLCODE:
14881 case SQLERRM:
14882 case STATIC:
14883 case SUBTYPE:
14884 case SUBSTITUTABLE:
14885 case SUCCESSFUL:
14886 case SYSDATE:
14887 case SYS_REFCURSOR:
14888 case TEMPORARY:
14889 case TIME:
14890 case TIMESTAMP:
14891 case TIMEZONE_REGION:
14892 case TIMEZONE_ABBR:
14893 case TIMEZONE_MINUTE:
14894 case TIMEZONE_HOUR:
14895 case TRANSACTION:
14896 case TRUE:
14897 case TYPE:
14898 case UNDER:
14899 case USING:
14900 case WHILE:
14901 case YES:
14902 case SHOW:
14903 case A:
14904 case UPDATE:
14905 case DOUBLE:
14906 case DEC:
14907 case PRECISION:
14908 case INT:
14909 case NUMERIC:
14910 case NCHAR:
14911 case NVARCHAR2:
14912 case STRING:
14913 case UROWID:
14914 case VARRAY:
14915 case VARYING:
14916 case BFILE:
14917 case BLOB:
14918 case CLOB:
14919 case NCLOB:
14920 case YEAR:
14921 case LOCAL:
14922 case WITH:
14923 case ZONE:
14924 case CHARACTER:
14925 case AFTER:
14926 case BEFORE:
14927 case OLD:
14928 case PARENT:
14929 case CC_IF:
14930 case CC_ERROR:
14931 case ANALYZE:
14932 case ASSOCIATE:
14933 case AUDIT:
14934 case COMPOUND:
14935 case DATABASE:
14936 case CALL:
14937 case DDL:
14938 case DISASSOCIATE:
14939 case EACH:
14940 case FOLLOWS:
14941 case LOGOFF:
14942 case LOGON:
14943 case NESTED:
14944 case NOAUDIT:
14945 case SCHEMA:
14946 case SERVERERROR:
14947 case SHUTDOWN:
14948 case STARTUP:
14949 case STATEMENT:
14950 case STATISTICS:
14951 case SUSPEND:
14952 case TRUNCATE:
14953 case WRAPPED:
14954 case LIBRARY:
14955 case NAME:
14956 case STRUCT:
14957 case CONTEXT:
14958 case PARAMETERS:
14959 case LENGTH:
14960 case TDO:
14961 case MAXLEN:
14962 case CHARSETID:
14963 case CHARSETFORM:
14964 case ACCEPT:
14965 case ACCESSIBLE:
14966 case COPY:
14967 case DEFINE:
14968 case DISCONNECT:
14969 case HOST:
14970 case PRINT:
14971 case QUIT:
14972 case REMARK:
14973 case UNDEFINE:
14974 case VARIABLE:
14975 case WHENEVER:
14976 case ATTACH:
14977 case CAST:
14978 case TREAT:
14979 case TRIM:
14980 case LEFT:
14981 case RIGHT:
14982 case BOTH:
14983 case EMPTY:
14984 case MULTISET:
14985 case SUBMULTISET:
14986 case LEADING:
14987 case TRAILING:
14988 case CHAR_CS:
14989 case NCHAR_CS:
14990 case DBTIMEZONE:
14991 case SESSIONTIMEZONE:
14992 case AUTHENTICATED:
14993 case LINK:
14994 case SHARED:
14995 case DIRECTORY:
14996 case USER:
14997 case IDENTIFIER:
14998 case UNSIGNED_NUMERIC_LITERAL:
14999 case CHARACTER_LITERAL:
15000 case STRING_LITERAL:
15001 case QUOTED_LITERAL:
15002 ;
15003 break;
15004 default:
15005 jj_la1[176] = jj_gen;
15006 break label_39;
15007 }
15008 Statement();
15009 }
15010 label_40:
15011 while (true) {
15012 switch (jj_nt.kind) {
15013 case CC_ELSIF:
15014 ;
15015 break;
15016 default:
15017 jj_la1[177] = jj_gen;
15018 break label_40;
15019 }
15020 jj_consume_token(CC_ELSIF);
15021 ConditionalOrExpression();
15022 jj_consume_token(CC_THEN);
15023 label_41:
15024 while (true) {
15025 Statement();
15026 switch (jj_nt.kind) {
15027 case 5:
15028 case 16:
15029 case 17:
15030 case 21:
15031 case REPLACE:
15032 case DEFINER:
15033 case CURRENT_USER:
15034 case LANGUAGE:
15035 case INLINE:
15036 case ADD:
15037 case AGGREGATE:
15038 case ARRAY:
15039 case AT:
15040 case ATTRIBUTE:
15041 case AUTHID:
15042 case BEGIN:
15043 case BODY:
15044 case BULK:
15045 case BYTE:
15046 case CASCADE:
15047 case CASE:
15048 case CLOSE:
15049 case COALESCE:
15050 case COLLECT:
15051 case COLUMN:
15052 case COMMENT:
15053 case COMMIT:
15054 case CONSTRUCTOR:
15055 case CONTINUE:
15056 case CONVERT:
15057 case CURRENT:
15058 case CURSOR:
15059 case DATA:
15060 case DATE:
15061 case DAY:
15062 case DECLARE:
15063 case DELETE:
15064 case DISABLE:
15065 case EDITIONABLE:
15066 case ELEMENT:
15067 case ENABLE:
15068 case ESCAPE:
15069 case EXCEPT:
15070 case EXCEPTIONS:
15071 case EXECUTE:
15072 case EXIT:
15073 case EXTERNAL:
15074 case EXTENDS:
15075 case EXTRACT:
15076 case FALSE:
15077 case FETCH:
15078 case FINAL:
15079 case FOR:
15080 case FORALL:
15081 case FORCE:
15082 case FUNCTION:
15083 case GLOBAL:
15084 case GOTO:
15085 case HASH:
15086 case HEAP:
15087 case HOUR:
15088 case IF:
15089 case IMMEDIATE:
15090 case INDICES:
15091 case INDEXTYPE:
15092 case INDICATOR:
15093 case INSERT:
15094 case INSTANTIABLE:
15095 case INTERVAL:
15096 case INVALIDATE:
15097 case ISOLATION:
15098 case JAVA:
15099 case LEVEL:
15100 case LIMIT:
15101 case LOCK:
15102 case LOOP:
15103 case MAP:
15104 case MAX:
15105 case MEMBER:
15106 case MERGE:
15107 case MIN:
15108 case MINUTE:
15109 case MLSLABEL:
15110 case MODIFY:
15111 case MOD:
15112 case MONTH:
15113 case NATURAL:
15114 case NEW:
15115 case NEW_DOT:
15116 case NO:
15117 case NONEDITIONABLE:
15118 case NOT:
15119 case NULL:
15120 case NULLIF:
15121 case OBJECT:
15122 case OID:
15123 case OPAQUE:
15124 case OPEN:
15125 case OPERATOR:
15126 case ORGANIZATION:
15127 case OTHERS:
15128 case OVERRIDING:
15129 case PACKAGE:
15130 case PARTITION:
15131 case PIPE:
15132 case PRAGMA:
15133 case PRESERVE:
15134 case PRIVATE:
15135 case PROCEDURE:
15136 case RAISE:
15137 case RANGE:
15138 case RAW:
15139 case REAL:
15140 case RECORD:
15141 case REF:
15142 case RELEASE:
15143 case RELIES_ON:
15144 case RENAME:
15145 case RESULT:
15146 case RETURN:
15147 case RETURNING:
15148 case REVERSE:
15149 case ROLLBACK:
15150 case ROW:
15151 case ROWS:
15152 case ROWID:
15153 case ROWNUM:
15154 case SAVE:
15155 case SAVEPOINT:
15156 case SECOND:
15157 case SELECT:
15158 case SELF:
15159 case SET:
15160 case SPACE:
15161 case SQL:
15162 case SQLCODE:
15163 case SQLERRM:
15164 case STATIC:
15165 case SUBTYPE:
15166 case SUBSTITUTABLE:
15167 case SUCCESSFUL:
15168 case SYSDATE:
15169 case SYS_REFCURSOR:
15170 case TEMPORARY:
15171 case TIME:
15172 case TIMESTAMP:
15173 case TIMEZONE_REGION:
15174 case TIMEZONE_ABBR:
15175 case TIMEZONE_MINUTE:
15176 case TIMEZONE_HOUR:
15177 case TRANSACTION:
15178 case TRUE:
15179 case TYPE:
15180 case UNDER:
15181 case USING:
15182 case WHILE:
15183 case YES:
15184 case SHOW:
15185 case A:
15186 case UPDATE:
15187 case DOUBLE:
15188 case DEC:
15189 case PRECISION:
15190 case INT:
15191 case NUMERIC:
15192 case NCHAR:
15193 case NVARCHAR2:
15194 case STRING:
15195 case UROWID:
15196 case VARRAY:
15197 case VARYING:
15198 case BFILE:
15199 case BLOB:
15200 case CLOB:
15201 case NCLOB:
15202 case YEAR:
15203 case LOCAL:
15204 case WITH:
15205 case ZONE:
15206 case CHARACTER:
15207 case AFTER:
15208 case BEFORE:
15209 case OLD:
15210 case PARENT:
15211 case CC_IF:
15212 case CC_ERROR:
15213 case ANALYZE:
15214 case ASSOCIATE:
15215 case AUDIT:
15216 case COMPOUND:
15217 case DATABASE:
15218 case CALL:
15219 case DDL:
15220 case DISASSOCIATE:
15221 case EACH:
15222 case FOLLOWS:
15223 case LOGOFF:
15224 case LOGON:
15225 case NESTED:
15226 case NOAUDIT:
15227 case SCHEMA:
15228 case SERVERERROR:
15229 case SHUTDOWN:
15230 case STARTUP:
15231 case STATEMENT:
15232 case STATISTICS:
15233 case SUSPEND:
15234 case TRUNCATE:
15235 case WRAPPED:
15236 case LIBRARY:
15237 case NAME:
15238 case STRUCT:
15239 case CONTEXT:
15240 case PARAMETERS:
15241 case LENGTH:
15242 case TDO:
15243 case MAXLEN:
15244 case CHARSETID:
15245 case CHARSETFORM:
15246 case ACCEPT:
15247 case ACCESSIBLE:
15248 case COPY:
15249 case DEFINE:
15250 case DISCONNECT:
15251 case HOST:
15252 case PRINT:
15253 case QUIT:
15254 case REMARK:
15255 case UNDEFINE:
15256 case VARIABLE:
15257 case WHENEVER:
15258 case ATTACH:
15259 case CAST:
15260 case TREAT:
15261 case TRIM:
15262 case LEFT:
15263 case RIGHT:
15264 case BOTH:
15265 case EMPTY:
15266 case MULTISET:
15267 case SUBMULTISET:
15268 case LEADING:
15269 case TRAILING:
15270 case CHAR_CS:
15271 case NCHAR_CS:
15272 case DBTIMEZONE:
15273 case SESSIONTIMEZONE:
15274 case AUTHENTICATED:
15275 case LINK:
15276 case SHARED:
15277 case DIRECTORY:
15278 case USER:
15279 case IDENTIFIER:
15280 case UNSIGNED_NUMERIC_LITERAL:
15281 case CHARACTER_LITERAL:
15282 case STRING_LITERAL:
15283 case QUOTED_LITERAL:
15284 ;
15285 break;
15286 default:
15287 jj_la1[178] = jj_gen;
15288 break label_41;
15289 }
15290 }
15291 }
15292 label_42:
15293 while (true) {
15294 switch (jj_nt.kind) {
15295 case CC_ELSE:
15296 ;
15297 break;
15298 default:
15299 jj_la1[179] = jj_gen;
15300 break label_42;
15301 }
15302 jj_consume_token(CC_ELSE);
15303 label_43:
15304 while (true) {
15305 Statement();
15306 switch (jj_nt.kind) {
15307 case 5:
15308 case 16:
15309 case 17:
15310 case 21:
15311 case REPLACE:
15312 case DEFINER:
15313 case CURRENT_USER:
15314 case LANGUAGE:
15315 case INLINE:
15316 case ADD:
15317 case AGGREGATE:
15318 case ARRAY:
15319 case AT:
15320 case ATTRIBUTE:
15321 case AUTHID:
15322 case BEGIN:
15323 case BODY:
15324 case BULK:
15325 case BYTE:
15326 case CASCADE:
15327 case CASE:
15328 case CLOSE:
15329 case COALESCE:
15330 case COLLECT:
15331 case COLUMN:
15332 case COMMENT:
15333 case COMMIT:
15334 case CONSTRUCTOR:
15335 case CONTINUE:
15336 case CONVERT:
15337 case CURRENT:
15338 case CURSOR:
15339 case DATA:
15340 case DATE:
15341 case DAY:
15342 case DECLARE:
15343 case DELETE:
15344 case DISABLE:
15345 case EDITIONABLE:
15346 case ELEMENT:
15347 case ENABLE:
15348 case ESCAPE:
15349 case EXCEPT:
15350 case EXCEPTIONS:
15351 case EXECUTE:
15352 case EXIT:
15353 case EXTERNAL:
15354 case EXTENDS:
15355 case EXTRACT:
15356 case FALSE:
15357 case FETCH:
15358 case FINAL:
15359 case FOR:
15360 case FORALL:
15361 case FORCE:
15362 case FUNCTION:
15363 case GLOBAL:
15364 case GOTO:
15365 case HASH:
15366 case HEAP:
15367 case HOUR:
15368 case IF:
15369 case IMMEDIATE:
15370 case INDICES:
15371 case INDEXTYPE:
15372 case INDICATOR:
15373 case INSERT:
15374 case INSTANTIABLE:
15375 case INTERVAL:
15376 case INVALIDATE:
15377 case ISOLATION:
15378 case JAVA:
15379 case LEVEL:
15380 case LIMIT:
15381 case LOCK:
15382 case LOOP:
15383 case MAP:
15384 case MAX:
15385 case MEMBER:
15386 case MERGE:
15387 case MIN:
15388 case MINUTE:
15389 case MLSLABEL:
15390 case MODIFY:
15391 case MOD:
15392 case MONTH:
15393 case NATURAL:
15394 case NEW:
15395 case NEW_DOT:
15396 case NO:
15397 case NONEDITIONABLE:
15398 case NOT:
15399 case NULL:
15400 case NULLIF:
15401 case OBJECT:
15402 case OID:
15403 case OPAQUE:
15404 case OPEN:
15405 case OPERATOR:
15406 case ORGANIZATION:
15407 case OTHERS:
15408 case OVERRIDING:
15409 case PACKAGE:
15410 case PARTITION:
15411 case PIPE:
15412 case PRAGMA:
15413 case PRESERVE:
15414 case PRIVATE:
15415 case PROCEDURE:
15416 case RAISE:
15417 case RANGE:
15418 case RAW:
15419 case REAL:
15420 case RECORD:
15421 case REF:
15422 case RELEASE:
15423 case RELIES_ON:
15424 case RENAME:
15425 case RESULT:
15426 case RETURN:
15427 case RETURNING:
15428 case REVERSE:
15429 case ROLLBACK:
15430 case ROW:
15431 case ROWS:
15432 case ROWID:
15433 case ROWNUM:
15434 case SAVE:
15435 case SAVEPOINT:
15436 case SECOND:
15437 case SELECT:
15438 case SELF:
15439 case SET:
15440 case SPACE:
15441 case SQL:
15442 case SQLCODE:
15443 case SQLERRM:
15444 case STATIC:
15445 case SUBTYPE:
15446 case SUBSTITUTABLE:
15447 case SUCCESSFUL:
15448 case SYSDATE:
15449 case SYS_REFCURSOR:
15450 case TEMPORARY:
15451 case TIME:
15452 case TIMESTAMP:
15453 case TIMEZONE_REGION:
15454 case TIMEZONE_ABBR:
15455 case TIMEZONE_MINUTE:
15456 case TIMEZONE_HOUR:
15457 case TRANSACTION:
15458 case TRUE:
15459 case TYPE:
15460 case UNDER:
15461 case USING:
15462 case WHILE:
15463 case YES:
15464 case SHOW:
15465 case A:
15466 case UPDATE:
15467 case DOUBLE:
15468 case DEC:
15469 case PRECISION:
15470 case INT:
15471 case NUMERIC:
15472 case NCHAR:
15473 case NVARCHAR2:
15474 case STRING:
15475 case UROWID:
15476 case VARRAY:
15477 case VARYING:
15478 case BFILE:
15479 case BLOB:
15480 case CLOB:
15481 case NCLOB:
15482 case YEAR:
15483 case LOCAL:
15484 case WITH:
15485 case ZONE:
15486 case CHARACTER:
15487 case AFTER:
15488 case BEFORE:
15489 case OLD:
15490 case PARENT:
15491 case CC_IF:
15492 case CC_ERROR:
15493 case ANALYZE:
15494 case ASSOCIATE:
15495 case AUDIT:
15496 case COMPOUND:
15497 case DATABASE:
15498 case CALL:
15499 case DDL:
15500 case DISASSOCIATE:
15501 case EACH:
15502 case FOLLOWS:
15503 case LOGOFF:
15504 case LOGON:
15505 case NESTED:
15506 case NOAUDIT:
15507 case SCHEMA:
15508 case SERVERERROR:
15509 case SHUTDOWN:
15510 case STARTUP:
15511 case STATEMENT:
15512 case STATISTICS:
15513 case SUSPEND:
15514 case TRUNCATE:
15515 case WRAPPED:
15516 case LIBRARY:
15517 case NAME:
15518 case STRUCT:
15519 case CONTEXT:
15520 case PARAMETERS:
15521 case LENGTH:
15522 case TDO:
15523 case MAXLEN:
15524 case CHARSETID:
15525 case CHARSETFORM:
15526 case ACCEPT:
15527 case ACCESSIBLE:
15528 case COPY:
15529 case DEFINE:
15530 case DISCONNECT:
15531 case HOST:
15532 case PRINT:
15533 case QUIT:
15534 case REMARK:
15535 case UNDEFINE:
15536 case VARIABLE:
15537 case WHENEVER:
15538 case ATTACH:
15539 case CAST:
15540 case TREAT:
15541 case TRIM:
15542 case LEFT:
15543 case RIGHT:
15544 case BOTH:
15545 case EMPTY:
15546 case MULTISET:
15547 case SUBMULTISET:
15548 case LEADING:
15549 case TRAILING:
15550 case CHAR_CS:
15551 case NCHAR_CS:
15552 case DBTIMEZONE:
15553 case SESSIONTIMEZONE:
15554 case AUTHENTICATED:
15555 case LINK:
15556 case SHARED:
15557 case DIRECTORY:
15558 case USER:
15559 case IDENTIFIER:
15560 case UNSIGNED_NUMERIC_LITERAL:
15561 case CHARACTER_LITERAL:
15562 case STRING_LITERAL:
15563 case QUOTED_LITERAL:
15564 ;
15565 break;
15566 default:
15567 jj_la1[180] = jj_gen;
15568 break label_43;
15569 }
15570 }
15571 }
15572 jj_consume_token(CC_END);
15573 break;
15574 case CC_ERROR:
15575 jj_consume_token(CC_ERROR);
15576 Expression();
15577 jj_consume_token(CC_END);
15578 break;
15579 default:
15580 jj_la1[181] = jj_gen;
15581 jj_consume_token(-1);
15582 throw new ParseException();
15583 }
15584 jjtree.closeNodeScope(jjtn000, true);
15585 jjtc000 = false;
15586 {if (true) return jjtn000 ;}
15587 } catch (Throwable jjte000) {
15588 if (jjtc000) {
15589 jjtree.clearNodeScope(jjtn000);
15590 jjtc000 = false;
15591 } else {
15592 jjtree.popNode();
15593 }
15594 if (jjte000 instanceof RuntimeException) {
15595 {if (true) throw (RuntimeException)jjte000;}
15596 }
15597 if (jjte000 instanceof ParseException) {
15598 {if (true) throw (ParseException)jjte000;}
15599 }
15600 {if (true) throw (Error)jjte000;}
15601 } finally {
15602 if (jjtc000) {
15603 jjtree.closeNodeScope(jjtn000, true);
15604 }
15605 }
15606 throw new Error("Missing return statement in function");
15607 }
15608
15609 final public ASTSubTypeDefinition SubTypeDefinition() throws ParseException {
15610
15611 ASTSubTypeDefinition jjtn000 = new ASTSubTypeDefinition(this, JJTSUBTYPEDEFINITION);
15612 boolean jjtc000 = true;
15613 jjtree.openNodeScope(jjtn000);Token start, subtype_name=null, constraint=null, base_type=null;
15614 Token collection = null, collection2 = null;
15615 PLSQLNode name = null;
15616 PLSQLNode startElement = null, endElement = null;
15617 PLSQLNode baseType = null, returnType = null, indexBy = null ;
15618 int lastField = 0;
15619 try {
15620 switch (jj_nt.kind) {
15621 case SUBTYPE:
15622 jj_consume_token(SUBTYPE);
15623 name = QualifiedID();
15624 jj_consume_token(IS);
15625 Datatype();
15626 switch (jj_nt.kind) {
15627 case 5:
15628 case RANGE:
15629 switch (jj_nt.kind) {
15630 case 5:
15631 jj_consume_token(5);
15632 jj_consume_token(IDENTIFIER);
15633 jj_consume_token(7);
15634 break;
15635 case RANGE:
15636 jj_consume_token(RANGE);
15637 UnaryExpression(true);
15638 jj_consume_token(12);
15639 UnaryExpression(true);
15640 break;
15641 default:
15642 jj_la1[182] = jj_gen;
15643 jj_consume_token(-1);
15644 throw new ParseException();
15645 }
15646 break;
15647 default:
15648 jj_la1[183] = jj_gen;
15649 ;
15650 }
15651 switch (jj_nt.kind) {
15652 case NOT:
15653 jj_consume_token(NOT);
15654 jj_consume_token(NULL);
15655 break;
15656 default:
15657 jj_la1[184] = jj_gen;
15658 ;
15659 }
15660 break;
15661 case TYPE:
15662 jj_consume_token(TYPE);
15663 name = QualifiedID();
15664 switch (jj_nt.kind) {
15665 case IS:
15666 jj_consume_token(IS);
15667 break;
15668 case AS:
15669 jj_consume_token(AS);
15670 break;
15671 default:
15672 jj_la1[185] = jj_gen;
15673 jj_consume_token(-1);
15674 throw new ParseException();
15675 }
15676 if (jj_2_44(2)) {
15677 jj_consume_token(NEW);
15678 switch (jj_nt.kind) {
15679 case CHAR_BASE:
15680 jj_consume_token(CHAR_BASE);
15681 break;
15682 case DATE_BASE:
15683 jj_consume_token(DATE_BASE);
15684 break;
15685 case CLOB_BASE:
15686 jj_consume_token(CLOB_BASE);
15687 break;
15688 case BLOB_BASE:
15689 jj_consume_token(BLOB_BASE);
15690 break;
15691 case BFILE_BASE:
15692 jj_consume_token(BFILE_BASE);
15693 break;
15694 case NUMBER_BASE:
15695 jj_consume_token(NUMBER_BASE);
15696 break;
15697 default:
15698 jj_la1[186] = jj_gen;
15699 jj_consume_token(-1);
15700 throw new ParseException();
15701 }
15702 } else {
15703 switch (jj_nt.kind) {
15704 case OBJECT:
15705 jj_consume_token(OBJECT);
15706 jj_consume_token(5);
15707 FieldDeclaration();
15708 label_44:
15709 while (true) {
15710 switch (jj_nt.kind) {
15711 case 6:
15712 ;
15713 break;
15714 default:
15715 jj_la1[187] = jj_gen;
15716 break label_44;
15717 }
15718 jj_consume_token(6);
15719 FieldDeclaration();
15720 }
15721 jj_consume_token(7);
15722 break;
15723 case RECORD:
15724 jj_consume_token(RECORD);
15725 jj_consume_token(5);
15726 FieldDeclaration();
15727 label_45:
15728 while (true) {
15729 switch (jj_nt.kind) {
15730 case 6:
15731 ;
15732 break;
15733 default:
15734 jj_la1[188] = jj_gen;
15735 break label_45;
15736 }
15737 jj_consume_token(6);
15738 FieldDeclaration();
15739 }
15740 jj_consume_token(7);
15741 break;
15742 case TABLE:
15743 case VARRAY:
15744 case VARYING:
15745 switch (jj_nt.kind) {
15746 case TABLE:
15747 jj_consume_token(TABLE);
15748 break;
15749 case VARRAY:
15750 jj_consume_token(VARRAY);
15751 break;
15752 case VARYING:
15753 jj_consume_token(VARYING);
15754 jj_consume_token(ARRAY);
15755 break;
15756 default:
15757 jj_la1[189] = jj_gen;
15758 jj_consume_token(-1);
15759 throw new ParseException();
15760 }
15761 switch (jj_nt.kind) {
15762 case 5:
15763 jj_consume_token(5);
15764 NumericLiteral();
15765 jj_consume_token(7);
15766 break;
15767 default:
15768 jj_la1[190] = jj_gen;
15769 ;
15770 }
15771 jj_consume_token(OF);
15772 Datatype();
15773 switch (jj_nt.kind) {
15774 case NOT:
15775 jj_consume_token(NOT);
15776 jj_consume_token(NULL);
15777 break;
15778 default:
15779 jj_la1[191] = jj_gen;
15780 ;
15781 }
15782 switch (jj_nt.kind) {
15783 case INDEX:
15784 jj_consume_token(INDEX);
15785 jj_consume_token(BY);
15786 Datatype();
15787 break;
15788 default:
15789 jj_la1[192] = jj_gen;
15790 ;
15791 }
15792 break;
15793 case REF:
15794 jj_consume_token(REF);
15795 jj_consume_token(CURSOR);
15796 switch (jj_nt.kind) {
15797 case RETURN:
15798 jj_consume_token(RETURN);
15799 Datatype();
15800 break;
15801 default:
15802 jj_la1[193] = jj_gen;
15803 ;
15804 }
15805 break;
15806 case 5:
15807 jj_consume_token(5);
15808 Expression();
15809 label_46:
15810 while (true) {
15811 switch (jj_nt.kind) {
15812 case 6:
15813 ;
15814 break;
15815 default:
15816 jj_la1[194] = jj_gen;
15817 break label_46;
15818 }
15819 jj_consume_token(6);
15820 Expression();
15821 }
15822 jj_consume_token(7);
15823 break;
15824 case REPLACE:
15825 case DEFINER:
15826 case CURRENT_USER:
15827 case LANGUAGE:
15828 case INLINE:
15829 case ADD:
15830 case AGGREGATE:
15831 case ARRAY:
15832 case AT:
15833 case ATTRIBUTE:
15834 case AUTHID:
15835 case BINARY_INTEGER:
15836 case BODY:
15837 case BOOLEAN:
15838 case BULK:
15839 case BYTE:
15840 case CASCADE:
15841 case CHAR:
15842 case CHAR_BASE:
15843 case CLOSE:
15844 case COALESCE:
15845 case COLLECT:
15846 case COLUMN:
15847 case COMMENT:
15848 case COMMIT:
15849 case CONSTRUCTOR:
15850 case CONTINUE:
15851 case CONVERT:
15852 case CURRENT:
15853 case CURSOR:
15854 case DATA:
15855 case DATE:
15856 case DAY:
15857 case DECIMAL:
15858 case DISABLE:
15859 case EDITIONABLE:
15860 case ELEMENT:
15861 case ENABLE:
15862 case ESCAPE:
15863 case EXCEPT:
15864 case EXCEPTIONS:
15865 case EXIT:
15866 case EXTERNAL:
15867 case EXTENDS:
15868 case EXTRACT:
15869 case FALSE:
15870 case FINAL:
15871 case FLOAT:
15872 case FORCE:
15873 case FUNCTION:
15874 case GLOBAL:
15875 case HASH:
15876 case HEAP:
15877 case HOUR:
15878 case IMMEDIATE:
15879 case INDICES:
15880 case INDEXTYPE:
15881 case INDICATOR:
15882 case INSTANTIABLE:
15883 case INTEGER:
15884 case INTERVAL:
15885 case INVALIDATE:
15886 case ISOLATION:
15887 case JAVA:
15888 case LEVEL:
15889 case LIMIT:
15890 case LONG:
15891 case LOOP:
15892 case MAP:
15893 case MAX:
15894 case MEMBER:
15895 case MERGE:
15896 case MIN:
15897 case MINUTE:
15898 case MLSLABEL:
15899 case MODIFY:
15900 case MOD:
15901 case MONTH:
15902 case NATURAL:
15903 case NATURALN:
15904 case NEW:
15905 case NO:
15906 case NONEDITIONABLE:
15907 case NULLIF:
15908 case NUMBER:
15909 case BFILE_BASE:
15910 case BLOB_BASE:
15911 case CLOB_BASE:
15912 case DATE_BASE:
15913 case NUMBER_BASE:
15914 case OID:
15915 case OPAQUE:
15916 case OPEN:
15917 case OPERATOR:
15918 case ORGANIZATION:
15919 case OTHERS:
15920 case OVERRIDING:
15921 case PACKAGE:
15922 case PARTITION:
15923 case PLS_INTEGER:
15924 case POSITIVE:
15925 case POSITIVEN:
15926 case PRESERVE:
15927 case PRIVATE:
15928 case PROCEDURE:
15929 case RANGE:
15930 case RAW:
15931 case REAL:
15932 case RELEASE:
15933 case RELIES_ON:
15934 case RENAME:
15935 case RESULT:
15936 case RETURN:
15937 case RETURNING:
15938 case REVERSE:
15939 case ROLLBACK:
15940 case ROW:
15941 case ROWS:
15942 case ROWID:
15943 case ROWNUM:
15944 case SAVE:
15945 case SAVEPOINT:
15946 case SECOND:
15947 case SELF:
15948 case SET:
15949 case SMALLINT:
15950 case SPACE:
15951 case SQL:
15952 case SQLCODE:
15953 case SQLERRM:
15954 case STATIC:
15955 case SUBTYPE:
15956 case SUBSTITUTABLE:
15957 case SUCCESSFUL:
15958 case SYSDATE:
15959 case SYS_REFCURSOR:
15960 case TEMPORARY:
15961 case TIME:
15962 case TIMESTAMP:
15963 case TIMEZONE_REGION:
15964 case TIMEZONE_ABBR:
15965 case TIMEZONE_MINUTE:
15966 case TIMEZONE_HOUR:
15967 case TRANSACTION:
15968 case TRUE:
15969 case TYPE:
15970 case UNDER:
15971 case USING:
15972 case YES:
15973 case SHOW:
15974 case A:
15975 case VARCHAR:
15976 case VARCHAR2:
15977 case DOUBLE:
15978 case DEC:
15979 case PRECISION:
15980 case INT:
15981 case NUMERIC:
15982 case SIGNTYPE:
15983 case NCHAR:
15984 case NVARCHAR2:
15985 case STRING:
15986 case UROWID:
15987 case BFILE:
15988 case BLOB:
15989 case CLOB:
15990 case NCLOB:
15991 case YEAR:
15992 case LOCAL:
15993 case ZONE:
15994 case CHARACTER:
15995 case AFTER:
15996 case BEFORE:
15997 case OLD:
15998 case PARENT:
15999 case CC_IF:
16000 case ANALYZE:
16001 case ASSOCIATE:
16002 case AUDIT:
16003 case COMPOUND:
16004 case DATABASE:
16005 case CALL:
16006 case DDL:
16007 case DISASSOCIATE:
16008 case EACH:
16009 case FOLLOWS:
16010 case LOGOFF:
16011 case LOGON:
16012 case NESTED:
16013 case NOAUDIT:
16014 case SCHEMA:
16015 case SERVERERROR:
16016 case SHUTDOWN:
16017 case STARTUP:
16018 case STATEMENT:
16019 case STATISTICS:
16020 case SUSPEND:
16021 case TRUNCATE:
16022 case WRAPPED:
16023 case LIBRARY:
16024 case NAME:
16025 case STRUCT:
16026 case CONTEXT:
16027 case PARAMETERS:
16028 case LENGTH:
16029 case TDO:
16030 case MAXLEN:
16031 case CHARSETID:
16032 case CHARSETFORM:
16033 case ACCEPT:
16034 case ACCESSIBLE:
16035 case COPY:
16036 case DEFINE:
16037 case DISCONNECT:
16038 case HOST:
16039 case PRINT:
16040 case QUIT:
16041 case REMARK:
16042 case UNDEFINE:
16043 case VARIABLE:
16044 case WHENEVER:
16045 case ATTACH:
16046 case CAST:
16047 case TREAT:
16048 case TRIM:
16049 case LEFT:
16050 case RIGHT:
16051 case BOTH:
16052 case EMPTY:
16053 case MULTISET:
16054 case SUBMULTISET:
16055 case LEADING:
16056 case TRAILING:
16057 case CHAR_CS:
16058 case NCHAR_CS:
16059 case DBTIMEZONE:
16060 case SESSIONTIMEZONE:
16061 case AUTHENTICATED:
16062 case LINK:
16063 case SHARED:
16064 case DIRECTORY:
16065 case USER:
16066 case IDENTIFIER:
16067 case QUOTED_LITERAL:
16068 Datatype();
16069 break;
16070 default:
16071 jj_la1[195] = jj_gen;
16072 jj_consume_token(-1);
16073 throw new ParseException();
16074 }
16075 }
16076 break;
16077 default:
16078 jj_la1[196] = jj_gen;
16079 jj_consume_token(-1);
16080 throw new ParseException();
16081 }
16082 jj_consume_token(4);
16083 jjtree.closeNodeScope(jjtn000, true);
16084 jjtc000 = false;
16085 jjtn000.setImage(name.getImage()) ; {if (true) return jjtn000 ;}
16086 } catch (Throwable jjte000) {
16087 if (jjtc000) {
16088 jjtree.clearNodeScope(jjtn000);
16089 jjtc000 = false;
16090 } else {
16091 jjtree.popNode();
16092 }
16093 if (jjte000 instanceof RuntimeException) {
16094 {if (true) throw (RuntimeException)jjte000;}
16095 }
16096 if (jjte000 instanceof ParseException) {
16097 {if (true) throw (ParseException)jjte000;}
16098 }
16099 {if (true) throw (Error)jjte000;}
16100 } finally {
16101 if (jjtc000) {
16102 jjtree.closeNodeScope(jjtn000, true);
16103 }
16104 }
16105 throw new Error("Missing return statement in function");
16106 }
16107
16108 final public ASTFieldDeclaration FieldDeclaration() throws ParseException {
16109
16110 ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
16111 boolean jjtc000 = true;
16112 jjtree.openNodeScope(jjtn000);PLSQLNode name;
16113 PLSQLNode dataType;
16114 PLSQLNode defaultValue = null;
16115 try {
16116 name = ID();
16117 Datatype();
16118 switch (jj_nt.kind) {
16119 case NOT:
16120 case NULL:
16121 switch (jj_nt.kind) {
16122 case NOT:
16123 jj_consume_token(NOT);
16124 break;
16125 default:
16126 jj_la1[197] = jj_gen;
16127 ;
16128 }
16129 jj_consume_token(NULL);
16130 break;
16131 default:
16132 jj_la1[198] = jj_gen;
16133 ;
16134 }
16135 switch (jj_nt.kind) {
16136 case 9:
16137 case _DEFAULT:
16138 switch (jj_nt.kind) {
16139 case 9:
16140 jj_consume_token(9);
16141 jj_consume_token(10);
16142 break;
16143 case _DEFAULT:
16144 jj_consume_token(_DEFAULT);
16145 break;
16146 default:
16147 jj_la1[199] = jj_gen;
16148 jj_consume_token(-1);
16149 throw new ParseException();
16150 }
16151 Expression();
16152 break;
16153 default:
16154 jj_la1[200] = jj_gen;
16155 ;
16156 }
16157 jjtree.closeNodeScope(jjtn000, true);
16158 jjtc000 = false;
16159 jjtn000.setImage(name.getImage()) ; {if (true) return jjtn000 ;}
16160 } catch (Throwable jjte000) {
16161 if (jjtc000) {
16162 jjtree.clearNodeScope(jjtn000);
16163 jjtc000 = false;
16164 } else {
16165 jjtree.popNode();
16166 }
16167 if (jjte000 instanceof RuntimeException) {
16168 {if (true) throw (RuntimeException)jjte000;}
16169 }
16170 if (jjte000 instanceof ParseException) {
16171 {if (true) throw (ParseException)jjte000;}
16172 }
16173 {if (true) throw (Error)jjte000;}
16174 } finally {
16175 if (jjtc000) {
16176 jjtree.closeNodeScope(jjtn000, true);
16177 }
16178 }
16179 throw new Error("Missing return statement in function");
16180 }
16181
16182 final public ASTCollectionTypeDefinition CollectionTypeDefinition() throws ParseException {
16183
16184 ASTCollectionTypeDefinition jjtn000 = new ASTCollectionTypeDefinition(this, JJTCOLLECTIONTYPEDEFINITION);
16185 boolean jjtc000 = true;
16186 jjtree.openNodeScope(jjtn000);Token t = null ;
16187 try {
16188 t = jj_consume_token(IDENTIFIER);
16189 jjtree.closeNodeScope(jjtn000, true);
16190 jjtc000 = false;
16191 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16192 } finally {
16193 if (jjtc000) {
16194 jjtree.closeNodeScope(jjtn000, true);
16195 }
16196 }
16197 throw new Error("Missing return statement in function");
16198 }
16199
16200 final public ASTCollectionDeclaration CollectionDeclaration() throws ParseException {
16201
16202 ASTCollectionDeclaration jjtn000 = new ASTCollectionDeclaration(this, JJTCOLLECTIONDECLARATION);
16203 boolean jjtc000 = true;
16204 jjtree.openNodeScope(jjtn000);Token t = null ;
16205 try {
16206 t = jj_consume_token(IDENTIFIER);
16207 jjtree.closeNodeScope(jjtn000, true);
16208 jjtc000 = false;
16209 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16210 } finally {
16211 if (jjtc000) {
16212 jjtree.closeNodeScope(jjtn000, true);
16213 }
16214 }
16215 throw new Error("Missing return statement in function");
16216 }
16217
16218 final public ASTObjectDeclaration ObjectDeclaration() throws ParseException {
16219
16220 ASTObjectDeclaration jjtn000 = new ASTObjectDeclaration(this, JJTOBJECTDECLARATION);
16221 boolean jjtc000 = true;
16222 jjtree.openNodeScope(jjtn000);Token t = null ;
16223 try {
16224 t = jj_consume_token(IDENTIFIER);
16225 jjtree.closeNodeScope(jjtn000, true);
16226 jjtc000 = false;
16227 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16228 } finally {
16229 if (jjtc000) {
16230 jjtree.closeNodeScope(jjtn000, true);
16231 }
16232 }
16233 throw new Error("Missing return statement in function");
16234 }
16235
16236
16237 final public ASTCallSpecTail CallSpecTail() throws ParseException {
16238
16239 ASTCallSpecTail jjtn000 = new ASTCallSpecTail(this, JJTCALLSPECTAIL);
16240 boolean jjtc000 = true;
16241 jjtree.openNodeScope(jjtn000);
16242 try {
16243 switch (jj_nt.kind) {
16244 case EXTERNAL:
16245 jj_consume_token(EXTERNAL);
16246 break;
16247 case LANGUAGE:
16248 jj_consume_token(LANGUAGE);
16249 switch (jj_nt.kind) {
16250 case IDENTIFIER:
16251 jj_consume_token(IDENTIFIER);
16252 break;
16253 case JAVA:
16254 jj_consume_token(JAVA);
16255 break;
16256 default:
16257 jj_la1[201] = jj_gen;
16258 jj_consume_token(-1);
16259 throw new ParseException();
16260 }
16261 break;
16262 default:
16263 jj_la1[202] = jj_gen;
16264 jj_consume_token(-1);
16265 throw new ParseException();
16266 }
16267 label_47:
16268 while (true) {
16269 switch (jj_nt.kind) {
16270 case WITH:
16271 case LIBRARY:
16272 case NAME:
16273 case PARAMETERS:
16274 ;
16275 break;
16276 default:
16277 jj_la1[203] = jj_gen;
16278 break label_47;
16279 }
16280 switch (jj_nt.kind) {
16281 case LIBRARY:
16282 jj_consume_token(LIBRARY);
16283 switch (jj_nt.kind) {
16284 case IDENTIFIER:
16285 jj_consume_token(IDENTIFIER);
16286 break;
16287 case QUOTED_LITERAL:
16288 jj_consume_token(QUOTED_LITERAL);
16289 break;
16290 case STRING_LITERAL:
16291 StringLiteral();
16292 break;
16293 default:
16294 jj_la1[204] = jj_gen;
16295 jj_consume_token(-1);
16296 throw new ParseException();
16297 }
16298 switch (jj_nt.kind) {
16299 case 3:
16300 jj_consume_token(3);
16301 switch (jj_nt.kind) {
16302 case IDENTIFIER:
16303 jj_consume_token(IDENTIFIER);
16304 break;
16305 case QUOTED_LITERAL:
16306 jj_consume_token(QUOTED_LITERAL);
16307 break;
16308 case STRING_LITERAL:
16309 StringLiteral();
16310 break;
16311 default:
16312 jj_la1[205] = jj_gen;
16313 jj_consume_token(-1);
16314 throw new ParseException();
16315 }
16316 break;
16317 default:
16318 jj_la1[206] = jj_gen;
16319 ;
16320 }
16321 break;
16322 case NAME:
16323 jj_consume_token(NAME);
16324 switch (jj_nt.kind) {
16325 case IDENTIFIER:
16326 jj_consume_token(IDENTIFIER);
16327 break;
16328 case QUOTED_LITERAL:
16329 jj_consume_token(QUOTED_LITERAL);
16330 break;
16331 case STRING_LITERAL:
16332 StringLiteral();
16333 break;
16334 default:
16335 jj_la1[207] = jj_gen;
16336 jj_consume_token(-1);
16337 throw new ParseException();
16338 }
16339 break;
16340 case WITH:
16341 jj_consume_token(WITH);
16342 jj_consume_token(CONTEXT);
16343 break;
16344 case PARAMETERS:
16345 jj_consume_token(PARAMETERS);
16346 SkipPastNextOccurrence(")");
16347 break;
16348 default:
16349 jj_la1[208] = jj_gen;
16350 jj_consume_token(-1);
16351 throw new ParseException();
16352 }
16353 }
16354 jjtree.closeNodeScope(jjtn000, true);
16355 jjtc000 = false;
16356 {if (true) return jjtn000 ;}
16357 } catch (Throwable jjte000) {
16358 if (jjtc000) {
16359 jjtree.clearNodeScope(jjtn000);
16360 jjtc000 = false;
16361 } else {
16362 jjtree.popNode();
16363 }
16364 if (jjte000 instanceof RuntimeException) {
16365 {if (true) throw (RuntimeException)jjte000;}
16366 }
16367 if (jjte000 instanceof ParseException) {
16368 {if (true) throw (ParseException)jjte000;}
16369 }
16370 {if (true) throw (Error)jjte000;}
16371 } finally {
16372 if (jjtc000) {
16373 jjtree.closeNodeScope(jjtn000, true);
16374 }
16375 }
16376 throw new Error("Missing return statement in function");
16377 }
16378
16379
16380 final public ASTCursorUnit CursorUnit() throws ParseException {
16381
16382 ASTCursorUnit jjtn000 = new ASTCursorUnit(this, JJTCURSORUNIT);
16383 boolean jjtc000 = true;
16384 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
16385 try {
16386 jj_consume_token(CURSOR);
16387 simpleNode = ID();
16388 switch (jj_nt.kind) {
16389 case 5:
16390 FormalParameters();
16391 break;
16392 default:
16393 jj_la1[209] = jj_gen;
16394 ;
16395 }
16396 switch (jj_nt.kind) {
16397 case RETURN:
16398 jj_consume_token(RETURN);
16399 Datatype();
16400 break;
16401 default:
16402 jj_la1[210] = jj_gen;
16403 ;
16404 }
16405 switch (jj_nt.kind) {
16406 case IS:
16407 jj_consume_token(IS);
16408 label_48:
16409 while (true) {
16410 switch (jj_nt.kind) {
16411 case 5:
16412 ;
16413 break;
16414 default:
16415 jj_la1[211] = jj_gen;
16416 break label_48;
16417 }
16418 jj_consume_token(5);
16419 }
16420 SqlStatement(null,";");
16421 break;
16422 default:
16423 jj_la1[212] = jj_gen;
16424 ;
16425 }
16426 jj_consume_token(4);
16427 jjtree.closeNodeScope(jjtn000, true);
16428 jjtc000 = false;
16429 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
16430 } catch (Throwable jjte000) {
16431 if (jjtc000) {
16432 jjtree.clearNodeScope(jjtn000);
16433 jjtc000 = false;
16434 } else {
16435 jjtree.popNode();
16436 }
16437 if (jjte000 instanceof RuntimeException) {
16438 {if (true) throw (RuntimeException)jjte000;}
16439 }
16440 if (jjte000 instanceof ParseException) {
16441 {if (true) throw (ParseException)jjte000;}
16442 }
16443 {if (true) throw (Error)jjte000;}
16444 } finally {
16445 if (jjtc000) {
16446 jjtree.closeNodeScope(jjtn000, true);
16447 }
16448 }
16449 throw new Error("Missing return statement in function");
16450 }
16451
16452 final public ASTCursorSpecification CursorSpecification() throws ParseException {
16453
16454 ASTCursorSpecification jjtn000 = new ASTCursorSpecification(this, JJTCURSORSPECIFICATION);
16455 boolean jjtc000 = true;
16456 jjtree.openNodeScope(jjtn000);
16457 try {
16458 CursorUnit();
16459 jjtree.closeNodeScope(jjtn000, true);
16460 jjtc000 = false;
16461 {if (true) return jjtn000 ;}
16462 } catch (Throwable jjte000) {
16463 if (jjtc000) {
16464 jjtree.clearNodeScope(jjtn000);
16465 jjtc000 = false;
16466 } else {
16467 jjtree.popNode();
16468 }
16469 if (jjte000 instanceof RuntimeException) {
16470 {if (true) throw (RuntimeException)jjte000;}
16471 }
16472 if (jjte000 instanceof ParseException) {
16473 {if (true) throw (ParseException)jjte000;}
16474 }
16475 {if (true) throw (Error)jjte000;}
16476 } finally {
16477 if (jjtc000) {
16478 jjtree.closeNodeScope(jjtn000, true);
16479 }
16480 }
16481 throw new Error("Missing return statement in function");
16482 }
16483
16484 final public ASTCursorBody CursorBody() throws ParseException {
16485
16486 ASTCursorBody jjtn000 = new ASTCursorBody(this, JJTCURSORBODY);
16487 boolean jjtc000 = true;
16488 jjtree.openNodeScope(jjtn000);
16489 try {
16490 CursorUnit();
16491 jjtree.closeNodeScope(jjtn000, true);
16492 jjtc000 = false;
16493 {if (true) return jjtn000 ;}
16494 } catch (Throwable jjte000) {
16495 if (jjtc000) {
16496 jjtree.clearNodeScope(jjtn000);
16497 jjtc000 = false;
16498 } else {
16499 jjtree.popNode();
16500 }
16501 if (jjte000 instanceof RuntimeException) {
16502 {if (true) throw (RuntimeException)jjte000;}
16503 }
16504 if (jjte000 instanceof ParseException) {
16505 {if (true) throw (ParseException)jjte000;}
16506 }
16507 {if (true) throw (Error)jjte000;}
16508 } finally {
16509 if (jjtc000) {
16510 jjtree.closeNodeScope(jjtn000, true);
16511 }
16512 }
16513 throw new Error("Missing return statement in function");
16514 }
16515
16516
16517
16518
16519
16520
16521
16522
16523
16524
16525
16526
16527
16528 final public ASTExpression Expression() throws ParseException {
16529
16530 ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
16531 boolean jjtc000 = true;
16532 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16533 StringBuilder sb = new StringBuilder() ;
16534 try {
16535 if (jj_2_45(2147483647)) {
16536 simpleNode = Assignment();
16537 sb.append(simpleNode.getImage());
16538 } else {
16539 switch (jj_nt.kind) {
16540 case 5:
16541 case 16:
16542 case 17:
16543 case REPLACE:
16544 case DEFINER:
16545 case CURRENT_USER:
16546 case LANGUAGE:
16547 case INLINE:
16548 case ADD:
16549 case AGGREGATE:
16550 case ARRAY:
16551 case AT:
16552 case ATTRIBUTE:
16553 case AUTHID:
16554 case BODY:
16555 case BULK:
16556 case BYTE:
16557 case CASCADE:
16558 case CASE:
16559 case CLOSE:
16560 case COALESCE:
16561 case COLLECT:
16562 case COLUMN:
16563 case COMMENT:
16564 case COMMIT:
16565 case CONSTRUCTOR:
16566 case CONTINUE:
16567 case CONVERT:
16568 case CURRENT:
16569 case CURSOR:
16570 case DATA:
16571 case DATE:
16572 case DAY:
16573 case DISABLE:
16574 case EDITIONABLE:
16575 case ELEMENT:
16576 case ENABLE:
16577 case ESCAPE:
16578 case EXCEPT:
16579 case EXCEPTIONS:
16580 case EXIT:
16581 case EXTERNAL:
16582 case EXTENDS:
16583 case EXTRACT:
16584 case FALSE:
16585 case FINAL:
16586 case FORCE:
16587 case FUNCTION:
16588 case GLOBAL:
16589 case HASH:
16590 case HEAP:
16591 case HOUR:
16592 case IMMEDIATE:
16593 case INDICES:
16594 case INDEXTYPE:
16595 case INDICATOR:
16596 case INSTANTIABLE:
16597 case INTERVAL:
16598 case INVALIDATE:
16599 case ISOLATION:
16600 case JAVA:
16601 case LEVEL:
16602 case LIMIT:
16603 case LOOP:
16604 case MAP:
16605 case MAX:
16606 case MEMBER:
16607 case MERGE:
16608 case MIN:
16609 case MINUTE:
16610 case MLSLABEL:
16611 case MODIFY:
16612 case MOD:
16613 case MONTH:
16614 case NATURAL:
16615 case NEW:
16616 case NEW_DOT:
16617 case NO:
16618 case NONEDITIONABLE:
16619 case NOT:
16620 case NULL:
16621 case NULLIF:
16622 case OBJECT:
16623 case OID:
16624 case OPAQUE:
16625 case OPEN:
16626 case OPERATOR:
16627 case ORGANIZATION:
16628 case OTHERS:
16629 case OVERRIDING:
16630 case PACKAGE:
16631 case PARTITION:
16632 case PRESERVE:
16633 case PRIVATE:
16634 case PROCEDURE:
16635 case RANGE:
16636 case RAW:
16637 case REAL:
16638 case RECORD:
16639 case REF:
16640 case RELEASE:
16641 case RELIES_ON:
16642 case RENAME:
16643 case RESULT:
16644 case RETURN:
16645 case RETURNING:
16646 case REVERSE:
16647 case ROLLBACK:
16648 case ROW:
16649 case ROWS:
16650 case ROWID:
16651 case ROWNUM:
16652 case SAVE:
16653 case SAVEPOINT:
16654 case SECOND:
16655 case SELECT:
16656 case SELF:
16657 case SET:
16658 case SPACE:
16659 case SQL:
16660 case SQLCODE:
16661 case SQLERRM:
16662 case STATIC:
16663 case SUBTYPE:
16664 case SUBSTITUTABLE:
16665 case SUCCESSFUL:
16666 case SYSDATE:
16667 case SYS_REFCURSOR:
16668 case TEMPORARY:
16669 case TIME:
16670 case TIMESTAMP:
16671 case TIMEZONE_REGION:
16672 case TIMEZONE_ABBR:
16673 case TIMEZONE_MINUTE:
16674 case TIMEZONE_HOUR:
16675 case TRANSACTION:
16676 case TRUE:
16677 case TYPE:
16678 case UNDER:
16679 case USING:
16680 case YES:
16681 case SHOW:
16682 case A:
16683 case DOUBLE:
16684 case DEC:
16685 case PRECISION:
16686 case INT:
16687 case NUMERIC:
16688 case NCHAR:
16689 case NVARCHAR2:
16690 case STRING:
16691 case UROWID:
16692 case VARRAY:
16693 case VARYING:
16694 case BFILE:
16695 case BLOB:
16696 case CLOB:
16697 case NCLOB:
16698 case YEAR:
16699 case LOCAL:
16700 case WITH:
16701 case ZONE:
16702 case CHARACTER:
16703 case AFTER:
16704 case BEFORE:
16705 case OLD:
16706 case PARENT:
16707 case ANALYZE:
16708 case ASSOCIATE:
16709 case AUDIT:
16710 case COMPOUND:
16711 case DATABASE:
16712 case CALL:
16713 case DDL:
16714 case DISASSOCIATE:
16715 case EACH:
16716 case FOLLOWS:
16717 case LOGOFF:
16718 case LOGON:
16719 case NESTED:
16720 case NOAUDIT:
16721 case SCHEMA:
16722 case SERVERERROR:
16723 case SHUTDOWN:
16724 case STARTUP:
16725 case STATEMENT:
16726 case STATISTICS:
16727 case SUSPEND:
16728 case TRUNCATE:
16729 case WRAPPED:
16730 case LIBRARY:
16731 case NAME:
16732 case STRUCT:
16733 case CONTEXT:
16734 case PARAMETERS:
16735 case LENGTH:
16736 case TDO:
16737 case MAXLEN:
16738 case CHARSETID:
16739 case CHARSETFORM:
16740 case ACCEPT:
16741 case ACCESSIBLE:
16742 case COPY:
16743 case DEFINE:
16744 case DISCONNECT:
16745 case HOST:
16746 case PRINT:
16747 case QUIT:
16748 case REMARK:
16749 case UNDEFINE:
16750 case VARIABLE:
16751 case WHENEVER:
16752 case ATTACH:
16753 case CAST:
16754 case TREAT:
16755 case TRIM:
16756 case LEFT:
16757 case RIGHT:
16758 case BOTH:
16759 case EMPTY:
16760 case MULTISET:
16761 case SUBMULTISET:
16762 case LEADING:
16763 case TRAILING:
16764 case CHAR_CS:
16765 case NCHAR_CS:
16766 case DBTIMEZONE:
16767 case SESSIONTIMEZONE:
16768 case AUTHENTICATED:
16769 case LINK:
16770 case SHARED:
16771 case DIRECTORY:
16772 case USER:
16773 case IDENTIFIER:
16774 case UNSIGNED_NUMERIC_LITERAL:
16775 case CHARACTER_LITERAL:
16776 case STRING_LITERAL:
16777 case QUOTED_LITERAL:
16778 simpleNode = ConditionalOrExpression();
16779 sb.append(simpleNode.getImage());
16780 break;
16781 case CC_IF:
16782 simpleNode = CompilationExpression();
16783 sb.append(simpleNode.getImage());
16784 break;
16785 default:
16786 jj_la1[213] = jj_gen;
16787 jj_consume_token(-1);
16788 throw new ParseException();
16789 }
16790 }
16791 jjtree.closeNodeScope(jjtn000, true);
16792 jjtc000 = false;
16793 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16794 } catch (Throwable jjte000) {
16795 if (jjtc000) {
16796 jjtree.clearNodeScope(jjtn000);
16797 jjtc000 = false;
16798 } else {
16799 jjtree.popNode();
16800 }
16801 if (jjte000 instanceof RuntimeException) {
16802 {if (true) throw (RuntimeException)jjte000;}
16803 }
16804 if (jjte000 instanceof ParseException) {
16805 {if (true) throw (ParseException)jjte000;}
16806 }
16807 {if (true) throw (Error)jjte000;}
16808 } finally {
16809 if (jjtc000) {
16810 jjtree.closeNodeScope(jjtn000, true);
16811 }
16812 }
16813 throw new Error("Missing return statement in function");
16814 }
16815
16816 final public ASTCompilationExpression CompilationExpression() throws ParseException {
16817
16818 ASTCompilationExpression jjtn000 = new ASTCompilationExpression(this, JJTCOMPILATIONEXPRESSION);
16819 boolean jjtc000 = true;
16820 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16821 StringBuilder sb = new StringBuilder() ;
16822 try {
16823 jj_consume_token(CC_IF);
16824 sb.append(" "); sb.append(token.image) ;
16825 simpleNode = ConditionalOrExpression();
16826 sb.append(" "); sb.append(simpleNode.getImage());
16827 jj_consume_token(CC_THEN);
16828 sb.append(" "); sb.append(token.image);
16829 simpleNode = Expression();
16830 sb.append(" "); sb.append(simpleNode.getImage());
16831 label_49:
16832 while (true) {
16833 switch (jj_nt.kind) {
16834 case CC_ELSIF:
16835 ;
16836 break;
16837 default:
16838 jj_la1[214] = jj_gen;
16839 break label_49;
16840 }
16841 jj_consume_token(CC_ELSIF);
16842 sb.append(" "); sb.append(token.image);
16843 simpleNode = ConditionalOrExpression();
16844 sb.append(" "); sb.append(simpleNode.getImage());
16845 jj_consume_token(CC_THEN);
16846 sb.append(" "); sb.append(token.image);
16847 simpleNode = Expression();
16848 sb.append(" "); sb.append(simpleNode.getImage());
16849 }
16850 label_50:
16851 while (true) {
16852 switch (jj_nt.kind) {
16853 case CC_ELSE:
16854 ;
16855 break;
16856 default:
16857 jj_la1[215] = jj_gen;
16858 break label_50;
16859 }
16860 jj_consume_token(CC_ELSE);
16861 sb.append(" "); sb.append(token.image);
16862 simpleNode = Expression();
16863 sb.append(" "); sb.append(simpleNode.getImage());
16864 }
16865 jj_consume_token(CC_END);
16866 sb.append(" "); sb.append(token.image);
16867 jjtree.closeNodeScope(jjtn000, true);
16868 jjtc000 = false;
16869 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16870 } catch (Throwable jjte000) {
16871 if (jjtc000) {
16872 jjtree.clearNodeScope(jjtn000);
16873 jjtc000 = false;
16874 } else {
16875 jjtree.popNode();
16876 }
16877 if (jjte000 instanceof RuntimeException) {
16878 {if (true) throw (RuntimeException)jjte000;}
16879 }
16880 if (jjte000 instanceof ParseException) {
16881 {if (true) throw (ParseException)jjte000;}
16882 }
16883 {if (true) throw (Error)jjte000;}
16884 } finally {
16885 if (jjtc000) {
16886 jjtree.closeNodeScope(jjtn000, true);
16887 }
16888 }
16889 throw new Error("Missing return statement in function");
16890 }
16891
16892 final public ASTAssignment Assignment() throws ParseException {
16893
16894 ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
16895 boolean jjtc000 = true;
16896 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16897 try {
16898 simpleNode = PrimaryExpression();
16899 sb.append(simpleNode.getImage());
16900 jj_consume_token(9);
16901 jj_consume_token(10);
16902 sb.append(" := ");
16903 simpleNode = Expression();
16904 sb.append(simpleNode.getImage());
16905 jjtree.closeNodeScope(jjtn000, true);
16906 jjtc000 = false;
16907 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16908 } catch (Throwable jjte000) {
16909 if (jjtc000) {
16910 jjtree.clearNodeScope(jjtn000);
16911 jjtc000 = false;
16912 } else {
16913 jjtree.popNode();
16914 }
16915 if (jjte000 instanceof RuntimeException) {
16916 {if (true) throw (RuntimeException)jjte000;}
16917 }
16918 if (jjte000 instanceof ParseException) {
16919 {if (true) throw (ParseException)jjte000;}
16920 }
16921 {if (true) throw (Error)jjte000;}
16922 } finally {
16923 if (jjtc000) {
16924 jjtree.closeNodeScope(jjtn000, true);
16925 }
16926 }
16927 throw new Error("Missing return statement in function");
16928 }
16929
16930 final public ASTCaseExpression CaseExpression() throws ParseException {
16931
16932 ASTCaseExpression jjtn000 = new ASTCaseExpression(this, JJTCASEEXPRESSION);
16933 boolean jjtc000 = true;
16934 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16935 try {
16936 thisToken = jj_consume_token(CASE);
16937 sb.append(thisToken.image);
16938 switch (jj_nt.kind) {
16939 case 5:
16940 case 16:
16941 case 17:
16942 case REPLACE:
16943 case DEFINER:
16944 case CURRENT_USER:
16945 case LANGUAGE:
16946 case INLINE:
16947 case ADD:
16948 case AGGREGATE:
16949 case ARRAY:
16950 case AT:
16951 case ATTRIBUTE:
16952 case AUTHID:
16953 case BODY:
16954 case BULK:
16955 case BYTE:
16956 case CASCADE:
16957 case CASE:
16958 case CLOSE:
16959 case COALESCE:
16960 case COLLECT:
16961 case COLUMN:
16962 case COMMENT:
16963 case COMMIT:
16964 case CONSTRUCTOR:
16965 case CONTINUE:
16966 case CONVERT:
16967 case CURRENT:
16968 case CURSOR:
16969 case DATA:
16970 case DATE:
16971 case DAY:
16972 case DISABLE:
16973 case EDITIONABLE:
16974 case ELEMENT:
16975 case ENABLE:
16976 case ESCAPE:
16977 case EXCEPT:
16978 case EXCEPTIONS:
16979 case EXIT:
16980 case EXTERNAL:
16981 case EXTENDS:
16982 case EXTRACT:
16983 case FALSE:
16984 case FINAL:
16985 case FORCE:
16986 case FUNCTION:
16987 case GLOBAL:
16988 case HASH:
16989 case HEAP:
16990 case HOUR:
16991 case IMMEDIATE:
16992 case INDICES:
16993 case INDEXTYPE:
16994 case INDICATOR:
16995 case INSTANTIABLE:
16996 case INTERVAL:
16997 case INVALIDATE:
16998 case ISOLATION:
16999 case JAVA:
17000 case LEVEL:
17001 case LIMIT:
17002 case LOOP:
17003 case MAP:
17004 case MAX:
17005 case MEMBER:
17006 case MERGE:
17007 case MIN:
17008 case MINUTE:
17009 case MLSLABEL:
17010 case MODIFY:
17011 case MOD:
17012 case MONTH:
17013 case NATURAL:
17014 case NEW:
17015 case NEW_DOT:
17016 case NO:
17017 case NONEDITIONABLE:
17018 case NOT:
17019 case NULL:
17020 case NULLIF:
17021 case OBJECT:
17022 case OID:
17023 case OPAQUE:
17024 case OPEN:
17025 case OPERATOR:
17026 case ORGANIZATION:
17027 case OTHERS:
17028 case OVERRIDING:
17029 case PACKAGE:
17030 case PARTITION:
17031 case PRESERVE:
17032 case PRIVATE:
17033 case PROCEDURE:
17034 case RANGE:
17035 case RAW:
17036 case REAL:
17037 case RECORD:
17038 case REF:
17039 case RELEASE:
17040 case RELIES_ON:
17041 case RENAME:
17042 case RESULT:
17043 case RETURN:
17044 case RETURNING:
17045 case REVERSE:
17046 case ROLLBACK:
17047 case ROW:
17048 case ROWS:
17049 case ROWID:
17050 case ROWNUM:
17051 case SAVE:
17052 case SAVEPOINT:
17053 case SECOND:
17054 case SELECT:
17055 case SELF:
17056 case SET:
17057 case SPACE:
17058 case SQL:
17059 case SQLCODE:
17060 case SQLERRM:
17061 case STATIC:
17062 case SUBTYPE:
17063 case SUBSTITUTABLE:
17064 case SUCCESSFUL:
17065 case SYSDATE:
17066 case SYS_REFCURSOR:
17067 case TEMPORARY:
17068 case TIME:
17069 case TIMESTAMP:
17070 case TIMEZONE_REGION:
17071 case TIMEZONE_ABBR:
17072 case TIMEZONE_MINUTE:
17073 case TIMEZONE_HOUR:
17074 case TRANSACTION:
17075 case TRUE:
17076 case TYPE:
17077 case UNDER:
17078 case USING:
17079 case YES:
17080 case SHOW:
17081 case A:
17082 case DOUBLE:
17083 case DEC:
17084 case PRECISION:
17085 case INT:
17086 case NUMERIC:
17087 case NCHAR:
17088 case NVARCHAR2:
17089 case STRING:
17090 case UROWID:
17091 case VARRAY:
17092 case VARYING:
17093 case BFILE:
17094 case BLOB:
17095 case CLOB:
17096 case NCLOB:
17097 case YEAR:
17098 case LOCAL:
17099 case WITH:
17100 case ZONE:
17101 case CHARACTER:
17102 case AFTER:
17103 case BEFORE:
17104 case OLD:
17105 case PARENT:
17106 case CC_IF:
17107 case ANALYZE:
17108 case ASSOCIATE:
17109 case AUDIT:
17110 case COMPOUND:
17111 case DATABASE:
17112 case CALL:
17113 case DDL:
17114 case DISASSOCIATE:
17115 case EACH:
17116 case FOLLOWS:
17117 case LOGOFF:
17118 case LOGON:
17119 case NESTED:
17120 case NOAUDIT:
17121 case SCHEMA:
17122 case SERVERERROR:
17123 case SHUTDOWN:
17124 case STARTUP:
17125 case STATEMENT:
17126 case STATISTICS:
17127 case SUSPEND:
17128 case TRUNCATE:
17129 case WRAPPED:
17130 case LIBRARY:
17131 case NAME:
17132 case STRUCT:
17133 case CONTEXT:
17134 case PARAMETERS:
17135 case LENGTH:
17136 case TDO:
17137 case MAXLEN:
17138 case CHARSETID:
17139 case CHARSETFORM:
17140 case ACCEPT:
17141 case ACCESSIBLE:
17142 case COPY:
17143 case DEFINE:
17144 case DISCONNECT:
17145 case HOST:
17146 case PRINT:
17147 case QUIT:
17148 case REMARK:
17149 case UNDEFINE:
17150 case VARIABLE:
17151 case WHENEVER:
17152 case ATTACH:
17153 case CAST:
17154 case TREAT:
17155 case TRIM:
17156 case LEFT:
17157 case RIGHT:
17158 case BOTH:
17159 case EMPTY:
17160 case MULTISET:
17161 case SUBMULTISET:
17162 case LEADING:
17163 case TRAILING:
17164 case CHAR_CS:
17165 case NCHAR_CS:
17166 case DBTIMEZONE:
17167 case SESSIONTIMEZONE:
17168 case AUTHENTICATED:
17169 case LINK:
17170 case SHARED:
17171 case DIRECTORY:
17172 case USER:
17173 case IDENTIFIER:
17174 case UNSIGNED_NUMERIC_LITERAL:
17175 case CHARACTER_LITERAL:
17176 case STRING_LITERAL:
17177 case QUOTED_LITERAL:
17178 simpleNode = Expression();
17179 sb.append(" "); sb.append(simpleNode.getImage());
17180 break;
17181 default:
17182 jj_la1[216] = jj_gen;
17183 ;
17184 }
17185 label_51:
17186 while (true) {
17187 thisToken = jj_consume_token(WHEN);
17188 sb.append(" "); sb.append(thisToken.image);
17189 simpleNode = Expression();
17190 sb.append(" "); sb.append(simpleNode.getImage());
17191 thisToken = jj_consume_token(THEN);
17192 sb.append(" "); sb.append(thisToken.image);
17193 Expression();
17194 sb.append(" "); sb.append(simpleNode.getImage());
17195 switch (jj_nt.kind) {
17196 case WHEN:
17197 ;
17198 break;
17199 default:
17200 jj_la1[217] = jj_gen;
17201 break label_51;
17202 }
17203 }
17204 switch (jj_nt.kind) {
17205 case ELSE:
17206 thisToken = jj_consume_token(ELSE);
17207 sb.append(" "); sb.append(thisToken.image);
17208 Expression();
17209 sb.append(" "); sb.append(simpleNode.getImage());
17210 break;
17211 default:
17212 jj_la1[218] = jj_gen;
17213 ;
17214 }
17215 thisToken = jj_consume_token(END);
17216 sb.append(" "); sb.append(thisToken.image);
17217 jjtree.closeNodeScope(jjtn000, true);
17218 jjtc000 = false;
17219 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17220 } catch (Throwable jjte000) {
17221 if (jjtc000) {
17222 jjtree.clearNodeScope(jjtn000);
17223 jjtc000 = false;
17224 } else {
17225 jjtree.popNode();
17226 }
17227 if (jjte000 instanceof RuntimeException) {
17228 {if (true) throw (RuntimeException)jjte000;}
17229 }
17230 if (jjte000 instanceof ParseException) {
17231 {if (true) throw (ParseException)jjte000;}
17232 }
17233 {if (true) throw (Error)jjte000;}
17234 } finally {
17235 if (jjtc000) {
17236 jjtree.closeNodeScope(jjtn000, true);
17237 }
17238 }
17239 throw new Error("Missing return statement in function");
17240 }
17241
17242
17243
17244
17245 final public ASTLikeExpression LikeExpression() throws ParseException {
17246
17247 ASTLikeExpression jjtn000 = new ASTLikeExpression(this, JJTLIKEEXPRESSION);
17248 boolean jjtc000 = true;
17249 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17250 try {
17251 simpleNode = PrimaryExpression();
17252 sb.append(" "); sb.append(simpleNode.getImage());
17253 thisToken = jj_consume_token(LIKE);
17254 sb.append(thisToken.image);
17255 simpleNode = StringExpression();
17256 sb.append(" "); sb.append(simpleNode.getImage());
17257 switch (jj_nt.kind) {
17258 case ESCAPE:
17259 jj_consume_token(ESCAPE);
17260 sb.append(" ESCAPE ");
17261 switch (jj_nt.kind) {
17262 case CHARACTER_LITERAL:
17263 jj_consume_token(CHARACTER_LITERAL);
17264 sb.append(" "); sb.append(token.toString());
17265 break;
17266 case STRING_LITERAL:
17267 simpleNode = StringLiteral();
17268 sb.append(" "); sb.append(simpleNode.getImage());
17269 break;
17270 default:
17271 jj_la1[219] = jj_gen;
17272 jj_consume_token(-1);
17273 throw new ParseException();
17274 }
17275 break;
17276 default:
17277 jj_la1[220] = jj_gen;
17278 ;
17279 }
17280 label_52:
17281 while (true) {
17282 switch (jj_nt.kind) {
17283 case 3:
17284 ;
17285 break;
17286 default:
17287 jj_la1[221] = jj_gen;
17288 break label_52;
17289 }
17290 jj_consume_token(3);
17291 simpleNode = Expression();
17292 sb.append("."); sb.append(simpleNode.getImage());
17293 }
17294 jjtree.closeNodeScope(jjtn000, true);
17295 jjtc000 = false;
17296 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17297 } catch (Throwable jjte000) {
17298 if (jjtc000) {
17299 jjtree.clearNodeScope(jjtn000);
17300 jjtc000 = false;
17301 } else {
17302 jjtree.popNode();
17303 }
17304 if (jjte000 instanceof RuntimeException) {
17305 {if (true) throw (RuntimeException)jjte000;}
17306 }
17307 if (jjte000 instanceof ParseException) {
17308 {if (true) throw (ParseException)jjte000;}
17309 }
17310 {if (true) throw (Error)jjte000;}
17311 } finally {
17312 if (jjtc000) {
17313 jjtree.closeNodeScope(jjtn000, true);
17314 }
17315 }
17316 throw new Error("Missing return statement in function");
17317 }
17318
17319 final public ASTTrimExpression TrimExpression() throws ParseException {
17320
17321 ASTTrimExpression jjtn000 = new ASTTrimExpression(this, JJTTRIMEXPRESSION);
17322 boolean jjtc000 = true;
17323 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17324 try {
17325 thisToken = jj_consume_token(TRIM);
17326 sb.append(thisToken.image);
17327 jj_consume_token(5);
17328 sb.append("(");
17329 switch (jj_nt.kind) {
17330 case BOTH:
17331 case LEADING:
17332 case TRAILING:
17333 switch (jj_nt.kind) {
17334 case LEADING:
17335 jj_consume_token(LEADING);
17336 break;
17337 case TRAILING:
17338 jj_consume_token(TRAILING);
17339 break;
17340 case BOTH:
17341 jj_consume_token(BOTH);
17342 break;
17343 default:
17344 jj_la1[222] = jj_gen;
17345 jj_consume_token(-1);
17346 throw new ParseException();
17347 }
17348 sb.append(" "); sb.append(token.toString());
17349 break;
17350 default:
17351 jj_la1[223] = jj_gen;
17352 ;
17353 }
17354 switch (jj_nt.kind) {
17355 case 5:
17356 case REPLACE:
17357 case DEFINER:
17358 case CURRENT_USER:
17359 case LANGUAGE:
17360 case INLINE:
17361 case ADD:
17362 case AGGREGATE:
17363 case ARRAY:
17364 case AT:
17365 case ATTRIBUTE:
17366 case AUTHID:
17367 case BODY:
17368 case BULK:
17369 case BYTE:
17370 case CASCADE:
17371 case CASE:
17372 case CLOSE:
17373 case COALESCE:
17374 case COLLECT:
17375 case COLUMN:
17376 case COMMENT:
17377 case COMMIT:
17378 case CONSTRUCTOR:
17379 case CONTINUE:
17380 case CONVERT:
17381 case CURRENT:
17382 case CURSOR:
17383 case DATA:
17384 case DATE:
17385 case DAY:
17386 case DISABLE:
17387 case EDITIONABLE:
17388 case ELEMENT:
17389 case ENABLE:
17390 case ESCAPE:
17391 case EXCEPT:
17392 case EXCEPTIONS:
17393 case EXIT:
17394 case EXTERNAL:
17395 case EXTENDS:
17396 case EXTRACT:
17397 case FALSE:
17398 case FINAL:
17399 case FORCE:
17400 case FUNCTION:
17401 case GLOBAL:
17402 case HASH:
17403 case HEAP:
17404 case HOUR:
17405 case IMMEDIATE:
17406 case INDICES:
17407 case INDEXTYPE:
17408 case INDICATOR:
17409 case INSTANTIABLE:
17410 case INTERVAL:
17411 case INVALIDATE:
17412 case ISOLATION:
17413 case JAVA:
17414 case LEVEL:
17415 case LIMIT:
17416 case LOOP:
17417 case MAP:
17418 case MAX:
17419 case MEMBER:
17420 case MERGE:
17421 case MIN:
17422 case MINUTE:
17423 case MLSLABEL:
17424 case MODIFY:
17425 case MOD:
17426 case MONTH:
17427 case NATURAL:
17428 case NEW:
17429 case NEW_DOT:
17430 case NO:
17431 case NONEDITIONABLE:
17432 case NULL:
17433 case NULLIF:
17434 case OBJECT:
17435 case OID:
17436 case OPAQUE:
17437 case OPEN:
17438 case OPERATOR:
17439 case ORGANIZATION:
17440 case OTHERS:
17441 case OVERRIDING:
17442 case PACKAGE:
17443 case PARTITION:
17444 case PRESERVE:
17445 case PRIVATE:
17446 case PROCEDURE:
17447 case RANGE:
17448 case RAW:
17449 case REAL:
17450 case RECORD:
17451 case REF:
17452 case RELEASE:
17453 case RELIES_ON:
17454 case RENAME:
17455 case RESULT:
17456 case RETURN:
17457 case RETURNING:
17458 case REVERSE:
17459 case ROLLBACK:
17460 case ROW:
17461 case ROWS:
17462 case ROWID:
17463 case ROWNUM:
17464 case SAVE:
17465 case SAVEPOINT:
17466 case SECOND:
17467 case SELECT:
17468 case SELF:
17469 case SET:
17470 case SPACE:
17471 case SQL:
17472 case SQLCODE:
17473 case SQLERRM:
17474 case STATIC:
17475 case SUBTYPE:
17476 case SUBSTITUTABLE:
17477 case SUCCESSFUL:
17478 case SYSDATE:
17479 case SYS_REFCURSOR:
17480 case TEMPORARY:
17481 case TIME:
17482 case TIMESTAMP:
17483 case TIMEZONE_REGION:
17484 case TIMEZONE_ABBR:
17485 case TIMEZONE_MINUTE:
17486 case TIMEZONE_HOUR:
17487 case TRANSACTION:
17488 case TRUE:
17489 case TYPE:
17490 case UNDER:
17491 case USING:
17492 case YES:
17493 case SHOW:
17494 case A:
17495 case DOUBLE:
17496 case DEC:
17497 case PRECISION:
17498 case INT:
17499 case NUMERIC:
17500 case NCHAR:
17501 case NVARCHAR2:
17502 case STRING:
17503 case UROWID:
17504 case VARRAY:
17505 case VARYING:
17506 case BFILE:
17507 case BLOB:
17508 case CLOB:
17509 case NCLOB:
17510 case YEAR:
17511 case LOCAL:
17512 case WITH:
17513 case ZONE:
17514 case CHARACTER:
17515 case AFTER:
17516 case BEFORE:
17517 case OLD:
17518 case PARENT:
17519 case ANALYZE:
17520 case ASSOCIATE:
17521 case AUDIT:
17522 case COMPOUND:
17523 case DATABASE:
17524 case CALL:
17525 case DDL:
17526 case DISASSOCIATE:
17527 case EACH:
17528 case FOLLOWS:
17529 case LOGOFF:
17530 case LOGON:
17531 case NESTED:
17532 case NOAUDIT:
17533 case SCHEMA:
17534 case SERVERERROR:
17535 case SHUTDOWN:
17536 case STARTUP:
17537 case STATEMENT:
17538 case STATISTICS:
17539 case SUSPEND:
17540 case TRUNCATE:
17541 case WRAPPED:
17542 case LIBRARY:
17543 case NAME:
17544 case STRUCT:
17545 case CONTEXT:
17546 case PARAMETERS:
17547 case LENGTH:
17548 case TDO:
17549 case MAXLEN:
17550 case CHARSETID:
17551 case CHARSETFORM:
17552 case ACCEPT:
17553 case ACCESSIBLE:
17554 case COPY:
17555 case DEFINE:
17556 case DISCONNECT:
17557 case HOST:
17558 case PRINT:
17559 case QUIT:
17560 case REMARK:
17561 case UNDEFINE:
17562 case VARIABLE:
17563 case WHENEVER:
17564 case ATTACH:
17565 case CAST:
17566 case TREAT:
17567 case TRIM:
17568 case LEFT:
17569 case RIGHT:
17570 case BOTH:
17571 case EMPTY:
17572 case MULTISET:
17573 case SUBMULTISET:
17574 case LEADING:
17575 case TRAILING:
17576 case CHAR_CS:
17577 case NCHAR_CS:
17578 case DBTIMEZONE:
17579 case SESSIONTIMEZONE:
17580 case AUTHENTICATED:
17581 case LINK:
17582 case SHARED:
17583 case DIRECTORY:
17584 case USER:
17585 case IDENTIFIER:
17586 case UNSIGNED_NUMERIC_LITERAL:
17587 case CHARACTER_LITERAL:
17588 case STRING_LITERAL:
17589 case QUOTED_LITERAL:
17590 simpleNode = StringExpression();
17591 sb.append(" "); sb.append(simpleNode.getImage());
17592 break;
17593 default:
17594 jj_la1[224] = jj_gen;
17595 ;
17596 }
17597 jj_consume_token(FROM);
17598 sb.append(thisToken.image);
17599 simpleNode = StringExpression();
17600 sb.append(" "); sb.append(simpleNode.getImage());
17601 jj_consume_token(7);
17602 sb.append(")");
17603 jjtree.closeNodeScope(jjtn000, true);
17604 jjtc000 = false;
17605 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17606 } catch (Throwable jjte000) {
17607 if (jjtc000) {
17608 jjtree.clearNodeScope(jjtn000);
17609 jjtc000 = false;
17610 } else {
17611 jjtree.popNode();
17612 }
17613 if (jjte000 instanceof RuntimeException) {
17614 {if (true) throw (RuntimeException)jjte000;}
17615 }
17616 if (jjte000 instanceof ParseException) {
17617 {if (true) throw (ParseException)jjte000;}
17618 }
17619 {if (true) throw (Error)jjte000;}
17620 } finally {
17621 if (jjtc000) {
17622 jjtree.closeNodeScope(jjtn000, true);
17623 }
17624 }
17625 throw new Error("Missing return statement in function");
17626 }
17627
17628
17629
17630
17631
17632 final public ASTObjectExpression ObjectExpression() throws ParseException {
17633
17634 ASTObjectExpression jjtn000 = new ASTObjectExpression(this, JJTOBJECTEXPRESSION);
17635 boolean jjtc000 = true;
17636 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17637 try {
17638 switch (jj_nt.kind) {
17639 case CAST:
17640 thisToken = jj_consume_token(CAST);
17641 break;
17642 case TREAT:
17643 thisToken = jj_consume_token(TREAT);
17644 break;
17645 default:
17646 jj_la1[225] = jj_gen;
17647 jj_consume_token(-1);
17648 throw new ParseException();
17649 }
17650 sb.append(thisToken.image);
17651 jj_consume_token(5);
17652 sb.append("(");
17653 simpleNode = Expression();
17654 sb.append(" "); sb.append(simpleNode.getImage());
17655 switch (jj_nt.kind) {
17656 case AT:
17657 jj_consume_token(AT);
17658 jj_consume_token(TIME);
17659 jj_consume_token(ZONE);
17660 simpleNode = PrimaryExpression();
17661 sb.append(" AT TIME ZONE "); sb.append(simpleNode.getImage());
17662 break;
17663 default:
17664 jj_la1[226] = jj_gen;
17665 ;
17666 }
17667 jj_consume_token(AS);
17668 sb.append(" AS ");
17669 simpleNode = Datatype();
17670 sb.append(" "); sb.append(simpleNode.getImage());
17671 jj_consume_token(7);
17672 sb.append(")");
17673 label_53:
17674 while (true) {
17675 switch (jj_nt.kind) {
17676 case 3:
17677 ;
17678 break;
17679 default:
17680 jj_la1[227] = jj_gen;
17681 break label_53;
17682 }
17683 jj_consume_token(3);
17684 Expression();
17685 }
17686 jjtree.closeNodeScope(jjtn000, true);
17687 jjtc000 = false;
17688 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17689 } catch (Throwable jjte000) {
17690 if (jjtc000) {
17691 jjtree.clearNodeScope(jjtn000);
17692 jjtc000 = false;
17693 } else {
17694 jjtree.popNode();
17695 }
17696 if (jjte000 instanceof RuntimeException) {
17697 {if (true) throw (RuntimeException)jjte000;}
17698 }
17699 if (jjte000 instanceof ParseException) {
17700 {if (true) throw (ParseException)jjte000;}
17701 }
17702 {if (true) throw (Error)jjte000;}
17703 } finally {
17704 if (jjtc000) {
17705 jjtree.closeNodeScope(jjtn000, true);
17706 }
17707 }
17708 throw new Error("Missing return statement in function");
17709 }
17710
17711 final public ASTConditionalOrExpression ConditionalOrExpression() throws ParseException {
17712
17713 ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
17714 boolean jjtc000 = true;
17715 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17716 try {
17717 simpleNode = ConditionalAndExpression();
17718 sb.append(simpleNode.getImage());
17719 label_54:
17720 while (true) {
17721 switch (jj_nt.kind) {
17722 case OR:
17723 ;
17724 break;
17725 default:
17726 jj_la1[228] = jj_gen;
17727 break label_54;
17728 }
17729 jj_consume_token(OR);
17730 sb.append(" OR ");
17731 simpleNode = ConditionalAndExpression();
17732 sb.append(simpleNode.getImage());
17733 }
17734 jjtree.closeNodeScope(jjtn000, true);
17735 jjtc000 = false;
17736 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17737 } catch (Throwable jjte000) {
17738 if (jjtc000) {
17739 jjtree.clearNodeScope(jjtn000);
17740 jjtc000 = false;
17741 } else {
17742 jjtree.popNode();
17743 }
17744 if (jjte000 instanceof RuntimeException) {
17745 {if (true) throw (RuntimeException)jjte000;}
17746 }
17747 if (jjte000 instanceof ParseException) {
17748 {if (true) throw (ParseException)jjte000;}
17749 }
17750 {if (true) throw (Error)jjte000;}
17751 } finally {
17752 if (jjtc000) {
17753 jjtree.closeNodeScope(jjtn000, true);
17754 }
17755 }
17756 throw new Error("Missing return statement in function");
17757 }
17758
17759 final public ASTConditionalAndExpression ConditionalAndExpression() throws ParseException {
17760
17761 ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
17762 boolean jjtc000 = true;
17763 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17764 try {
17765 simpleNode = EqualityExpression();
17766 sb.append(simpleNode.getImage());
17767 label_55:
17768 while (true) {
17769 switch (jj_nt.kind) {
17770 case AND:
17771 ;
17772 break;
17773 default:
17774 jj_la1[229] = jj_gen;
17775 break label_55;
17776 }
17777 jj_consume_token(AND);
17778 sb.append(" AND ");
17779 simpleNode = EqualityExpression();
17780 sb.append(simpleNode.getImage());
17781 }
17782 jjtree.closeNodeScope(jjtn000, true);
17783 jjtc000 = false;
17784 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17785 } catch (Throwable jjte000) {
17786 if (jjtc000) {
17787 jjtree.clearNodeScope(jjtn000);
17788 jjtc000 = false;
17789 } else {
17790 jjtree.popNode();
17791 }
17792 if (jjte000 instanceof RuntimeException) {
17793 {if (true) throw (RuntimeException)jjte000;}
17794 }
17795 if (jjte000 instanceof ParseException) {
17796 {if (true) throw (ParseException)jjte000;}
17797 }
17798 {if (true) throw (Error)jjte000;}
17799 } finally {
17800 if (jjtc000) {
17801 jjtree.closeNodeScope(jjtn000, true);
17802 }
17803 }
17804 throw new Error("Missing return statement in function");
17805 }
17806
17807 final public ASTEqualityExpression EqualityExpression() throws ParseException {
17808
17809 ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
17810 boolean jjtc000 = true;
17811 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17812 try {
17813 simpleNode = RelationalExpression();
17814 sb.append(simpleNode.getImage());
17815 label_56:
17816 while (true) {
17817 switch (jj_nt.kind) {
17818 case 10:
17819 case 13:
17820 case IS:
17821 ;
17822 break;
17823 default:
17824 jj_la1[230] = jj_gen;
17825 break label_56;
17826 }
17827 switch (jj_nt.kind) {
17828 case 10:
17829 jj_consume_token(10);
17830 sb.append(" = ");
17831 break;
17832 case 13:
17833 jj_consume_token(13);
17834 jj_consume_token(10);
17835 sb.append(" != ");
17836 break;
17837 case IS:
17838 jj_consume_token(IS);
17839 sb.append(" IS ");
17840 break;
17841 default:
17842 jj_la1[231] = jj_gen;
17843 jj_consume_token(-1);
17844 throw new ParseException();
17845 }
17846 simpleNode = RelationalExpression();
17847 sb.append(simpleNode.getImage());
17848 }
17849 jjtree.closeNodeScope(jjtn000, true);
17850 jjtc000 = false;
17851 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17852 } catch (Throwable jjte000) {
17853 if (jjtc000) {
17854 jjtree.clearNodeScope(jjtn000);
17855 jjtc000 = false;
17856 } else {
17857 jjtree.popNode();
17858 }
17859 if (jjte000 instanceof RuntimeException) {
17860 {if (true) throw (RuntimeException)jjte000;}
17861 }
17862 if (jjte000 instanceof ParseException) {
17863 {if (true) throw (ParseException)jjte000;}
17864 }
17865 {if (true) throw (Error)jjte000;}
17866 } finally {
17867 if (jjtc000) {
17868 jjtree.closeNodeScope(jjtn000, true);
17869 }
17870 }
17871 throw new Error("Missing return statement in function");
17872 }
17873
17874
17875
17876
17877 final public ASTRelationalExpression RelationalExpression() throws ParseException {
17878
17879 ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
17880 boolean jjtc000 = true;
17881 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17882 try {
17883 simpleNode = AdditiveExpression();
17884 sb.append(simpleNode.getImage());
17885 label_57:
17886 while (true) {
17887 switch (jj_nt.kind) {
17888 case 14:
17889 case 15:
17890 case BETWEEN:
17891 case FROM:
17892 case IN:
17893 case LIKE:
17894 case MEMBER:
17895 case NOT:
17896 case MULTISET:
17897 case SUBMULTISET:
17898 ;
17899 break;
17900 default:
17901 jj_la1[232] = jj_gen;
17902 break label_57;
17903 }
17904 switch (jj_nt.kind) {
17905 case 14:
17906 case 15:
17907 switch (jj_nt.kind) {
17908 case 14:
17909 jj_consume_token(14);
17910 sb.append("<");
17911 switch (jj_nt.kind) {
17912 case 15:
17913 jj_consume_token(15);
17914 sb.append(">");
17915 break;
17916 default:
17917 jj_la1[233] = jj_gen;
17918 ;
17919 }
17920 break;
17921 case 15:
17922 jj_consume_token(15);
17923 sb.append(">");
17924 break;
17925 default:
17926 jj_la1[234] = jj_gen;
17927 jj_consume_token(-1);
17928 throw new ParseException();
17929 }
17930 switch (jj_nt.kind) {
17931 case 10:
17932 jj_consume_token(10);
17933 sb.append("=");
17934 break;
17935 default:
17936 jj_la1[235] = jj_gen;
17937 ;
17938 }
17939 sb.append(" ");
17940 break;
17941 case BETWEEN:
17942 case FROM:
17943 case IN:
17944 case LIKE:
17945 case MEMBER:
17946 case NOT:
17947 case SUBMULTISET:
17948 switch (jj_nt.kind) {
17949 case NOT:
17950 jj_consume_token(NOT);
17951 sb.append(" NOT ");
17952 break;
17953 default:
17954 jj_la1[236] = jj_gen;
17955 ;
17956 }
17957 switch (jj_nt.kind) {
17958 case IN:
17959 jj_consume_token(IN);
17960 sb.append(" IN ");
17961 break;
17962 case BETWEEN:
17963 jj_consume_token(BETWEEN);
17964 sb.append(" BETWEEN ");
17965 break;
17966 case LIKE:
17967 jj_consume_token(LIKE);
17968 sb.append(" LIKE ");
17969 break;
17970 case FROM:
17971 jj_consume_token(FROM);
17972 sb.append(" FROM ");
17973 break;
17974 case MEMBER:
17975 case SUBMULTISET:
17976 switch (jj_nt.kind) {
17977 case MEMBER:
17978 jj_consume_token(MEMBER);
17979 sb.append(" MEMBER ");
17980 break;
17981 case SUBMULTISET:
17982 jj_consume_token(SUBMULTISET);
17983 sb.append(" SUBMULTISET ");
17984 break;
17985 default:
17986 jj_la1[237] = jj_gen;
17987 jj_consume_token(-1);
17988 throw new ParseException();
17989 }
17990 switch (jj_nt.kind) {
17991 case OF:
17992 jj_consume_token(OF);
17993 sb.append(" OF ");
17994 break;
17995 default:
17996 jj_la1[238] = jj_gen;
17997 ;
17998 }
17999 break;
18000 default:
18001 jj_la1[239] = jj_gen;
18002 jj_consume_token(-1);
18003 throw new ParseException();
18004 }
18005 break;
18006 case MULTISET:
18007 jj_consume_token(MULTISET);
18008 sb.append (" MULTISET " );
18009 switch (jj_nt.kind) {
18010 case EXCEPT:
18011 jj_consume_token(EXCEPT);
18012 sb.append (" EXCEPT " );
18013 break;
18014 case INTERSECT:
18015 jj_consume_token(INTERSECT);
18016 sb.append (" INTERSECT " );
18017 break;
18018 case UNION:
18019 jj_consume_token(UNION);
18020 sb.append (" UNION " );
18021 break;
18022 default:
18023 jj_la1[240] = jj_gen;
18024 jj_consume_token(-1);
18025 throw new ParseException();
18026 }
18027 switch (jj_nt.kind) {
18028 case ALL:
18029 case DISTINCT:
18030 switch (jj_nt.kind) {
18031 case DISTINCT:
18032 jj_consume_token(DISTINCT);
18033 sb.append (" DISTINCT " );
18034 break;
18035 case ALL:
18036 jj_consume_token(ALL);
18037 sb.append (" ALL " );
18038 break;
18039 default:
18040 jj_la1[241] = jj_gen;
18041 jj_consume_token(-1);
18042 throw new ParseException();
18043 }
18044 break;
18045 default:
18046 jj_la1[242] = jj_gen;
18047 ;
18048 }
18049 break;
18050 default:
18051 jj_la1[243] = jj_gen;
18052 jj_consume_token(-1);
18053 throw new ParseException();
18054 }
18055 AdditiveExpression();
18056 sb.append(simpleNode.getImage());
18057 switch (jj_nt.kind) {
18058 case ESCAPE:
18059 jj_consume_token(ESCAPE);
18060 sb.append(" ESCAPE ");
18061 switch (jj_nt.kind) {
18062 case CHARACTER_LITERAL:
18063 jj_consume_token(CHARACTER_LITERAL);
18064 sb.append(" "); sb.append(token.toString());
18065 break;
18066 case STRING_LITERAL:
18067 simpleNode = StringLiteral();
18068 sb.append(" "); sb.append(simpleNode.getImage());
18069 break;
18070 default:
18071 jj_la1[244] = jj_gen;
18072 jj_consume_token(-1);
18073 throw new ParseException();
18074 }
18075 break;
18076 default:
18077 jj_la1[245] = jj_gen;
18078 ;
18079 }
18080 }
18081 jjtree.closeNodeScope(jjtn000, true);
18082 jjtc000 = false;
18083 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18084 } catch (Throwable jjte000) {
18085 if (jjtc000) {
18086 jjtree.clearNodeScope(jjtn000);
18087 jjtc000 = false;
18088 } else {
18089 jjtree.popNode();
18090 }
18091 if (jjte000 instanceof RuntimeException) {
18092 {if (true) throw (RuntimeException)jjte000;}
18093 }
18094 if (jjte000 instanceof ParseException) {
18095 {if (true) throw (ParseException)jjte000;}
18096 }
18097 {if (true) throw (Error)jjte000;}
18098 } finally {
18099 if (jjtc000) {
18100 jjtree.closeNodeScope(jjtn000, true);
18101 }
18102 }
18103 throw new Error("Missing return statement in function");
18104 }
18105
18106 final public ASTAdditiveExpression AdditiveExpression() throws ParseException {
18107
18108 ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
18109 boolean jjtc000 = true;
18110 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18111 try {
18112 simpleNode = MultiplicativeExpression();
18113 sb.append(simpleNode.getImage());
18114 label_58:
18115 while (true) {
18116 switch (jj_nt.kind) {
18117 case 16:
18118 case 17:
18119 case 18:
18120 ;
18121 break;
18122 default:
18123 jj_la1[246] = jj_gen;
18124 break label_58;
18125 }
18126 switch (jj_nt.kind) {
18127 case 16:
18128 jj_consume_token(16);
18129 sb.append(" + ");
18130 break;
18131 case 17:
18132 jj_consume_token(17);
18133 sb.append(" - ");
18134 break;
18135 case 18:
18136 jj_consume_token(18);
18137 sb.append(" || ");
18138 break;
18139 default:
18140 jj_la1[247] = jj_gen;
18141 jj_consume_token(-1);
18142 throw new ParseException();
18143 }
18144 simpleNode = MultiplicativeExpression();
18145 sb.append(simpleNode.getImage());
18146 }
18147 jjtree.closeNodeScope(jjtn000, true);
18148 jjtc000 = false;
18149 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18150 } catch (Throwable jjte000) {
18151 if (jjtc000) {
18152 jjtree.clearNodeScope(jjtn000);
18153 jjtc000 = false;
18154 } else {
18155 jjtree.popNode();
18156 }
18157 if (jjte000 instanceof RuntimeException) {
18158 {if (true) throw (RuntimeException)jjte000;}
18159 }
18160 if (jjte000 instanceof ParseException) {
18161 {if (true) throw (ParseException)jjte000;}
18162 }
18163 {if (true) throw (Error)jjte000;}
18164 } finally {
18165 if (jjtc000) {
18166 jjtree.closeNodeScope(jjtn000, true);
18167 }
18168 }
18169 throw new Error("Missing return statement in function");
18170 }
18171
18172 final public ASTStringExpression StringExpression() throws ParseException {
18173
18174 ASTStringExpression jjtn000 = new ASTStringExpression(this, JJTSTRINGEXPRESSION);
18175 boolean jjtc000 = true;
18176 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18177 try {
18178 simpleNode = PrimaryExpression();
18179 sb.append(simpleNode.getImage());
18180 label_59:
18181 while (true) {
18182 switch (jj_nt.kind) {
18183 case 18:
18184 ;
18185 break;
18186 default:
18187 jj_la1[248] = jj_gen;
18188 break label_59;
18189 }
18190 jj_consume_token(18);
18191 sb.append(" || ");
18192 simpleNode = PrimaryExpression();
18193 sb.append(simpleNode.getImage());
18194 }
18195 jjtree.closeNodeScope(jjtn000, true);
18196 jjtc000 = false;
18197 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18198 } catch (Throwable jjte000) {
18199 if (jjtc000) {
18200 jjtree.clearNodeScope(jjtn000);
18201 jjtc000 = false;
18202 } else {
18203 jjtree.popNode();
18204 }
18205 if (jjte000 instanceof RuntimeException) {
18206 {if (true) throw (RuntimeException)jjte000;}
18207 }
18208 if (jjte000 instanceof ParseException) {
18209 {if (true) throw (ParseException)jjte000;}
18210 }
18211 {if (true) throw (Error)jjte000;}
18212 } finally {
18213 if (jjtc000) {
18214 jjtree.closeNodeScope(jjtn000, true);
18215 }
18216 }
18217 throw new Error("Missing return statement in function");
18218 }
18219
18220 final public ASTMultiplicativeExpression MultiplicativeExpression() throws ParseException {
18221
18222 ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
18223 boolean jjtc000 = true;
18224 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18225 try {
18226 simpleNode = UnaryExpression(true);
18227 sb.append(simpleNode.getImage());
18228 label_60:
18229 while (true) {
18230 switch (jj_nt.kind) {
18231 case 1:
18232 case 19:
18233 case 20:
18234 case MOD:
18235 ;
18236 break;
18237 default:
18238 jj_la1[249] = jj_gen;
18239 break label_60;
18240 }
18241 switch (jj_nt.kind) {
18242 case 19:
18243 jj_consume_token(19);
18244 sb.append(" ** ");
18245 break;
18246 case 20:
18247 jj_consume_token(20);
18248 sb.append(" * ");
18249 break;
18250 case 1:
18251 jj_consume_token(1);
18252 sb.append(" / ");
18253 break;
18254 case MOD:
18255 jj_consume_token(MOD);
18256 sb.append(" MOD ");
18257 break;
18258 default:
18259 jj_la1[250] = jj_gen;
18260 jj_consume_token(-1);
18261 throw new ParseException();
18262 }
18263 simpleNode = UnaryExpression(true);
18264 sb.append(simpleNode.getImage());
18265 }
18266 jjtree.closeNodeScope(jjtn000, true);
18267 jjtc000 = false;
18268 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18269 } catch (Throwable jjte000) {
18270 if (jjtc000) {
18271 jjtree.clearNodeScope(jjtn000);
18272 jjtc000 = false;
18273 } else {
18274 jjtree.popNode();
18275 }
18276 if (jjte000 instanceof RuntimeException) {
18277 {if (true) throw (RuntimeException)jjte000;}
18278 }
18279 if (jjte000 instanceof ParseException) {
18280 {if (true) throw (ParseException)jjte000;}
18281 }
18282 {if (true) throw (Error)jjte000;}
18283 } finally {
18284 if (jjtc000) {
18285 jjtree.closeNodeScope(jjtn000, true);
18286 }
18287 }
18288 throw new Error("Missing return statement in function");
18289 }
18290
18291 final public ASTUnaryExpression UnaryExpression(boolean isUnarySign) throws ParseException {
18292
18293 ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
18294 boolean jjtc000 = true;
18295 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18296 try {
18297 switch (jj_nt.kind) {
18298 case 16:
18299 case 17:
18300 switch (jj_nt.kind) {
18301 case 16:
18302 jj_consume_token(16);
18303 sb.append(isUnarySign ? " +" : " + ");
18304 break;
18305 case 17:
18306 jj_consume_token(17);
18307 sb.append(isUnarySign ? " -" : " - ");
18308 break;
18309 default:
18310 jj_la1[251] = jj_gen;
18311 jj_consume_token(-1);
18312 throw new ParseException();
18313 }
18314 simpleNode = UnaryExpression(false);
18315 sb.append(simpleNode.getImage());
18316 break;
18317 case 5:
18318 case REPLACE:
18319 case DEFINER:
18320 case CURRENT_USER:
18321 case LANGUAGE:
18322 case INLINE:
18323 case ADD:
18324 case AGGREGATE:
18325 case ARRAY:
18326 case AT:
18327 case ATTRIBUTE:
18328 case AUTHID:
18329 case BODY:
18330 case BULK:
18331 case BYTE:
18332 case CASCADE:
18333 case CASE:
18334 case CLOSE:
18335 case COALESCE:
18336 case COLLECT:
18337 case COLUMN:
18338 case COMMENT:
18339 case COMMIT:
18340 case CONSTRUCTOR:
18341 case CONTINUE:
18342 case CONVERT:
18343 case CURRENT:
18344 case CURSOR:
18345 case DATA:
18346 case DATE:
18347 case DAY:
18348 case DISABLE:
18349 case EDITIONABLE:
18350 case ELEMENT:
18351 case ENABLE:
18352 case ESCAPE:
18353 case EXCEPT:
18354 case EXCEPTIONS:
18355 case EXIT:
18356 case EXTERNAL:
18357 case EXTENDS:
18358 case EXTRACT:
18359 case FALSE:
18360 case FINAL:
18361 case FORCE:
18362 case FUNCTION:
18363 case GLOBAL:
18364 case HASH:
18365 case HEAP:
18366 case HOUR:
18367 case IMMEDIATE:
18368 case INDICES:
18369 case INDEXTYPE:
18370 case INDICATOR:
18371 case INSTANTIABLE:
18372 case INTERVAL:
18373 case INVALIDATE:
18374 case ISOLATION:
18375 case JAVA:
18376 case LEVEL:
18377 case LIMIT:
18378 case LOOP:
18379 case MAP:
18380 case MAX:
18381 case MEMBER:
18382 case MERGE:
18383 case MIN:
18384 case MINUTE:
18385 case MLSLABEL:
18386 case MODIFY:
18387 case MOD:
18388 case MONTH:
18389 case NATURAL:
18390 case NEW:
18391 case NEW_DOT:
18392 case NO:
18393 case NONEDITIONABLE:
18394 case NOT:
18395 case NULL:
18396 case NULLIF:
18397 case OBJECT:
18398 case OID:
18399 case OPAQUE:
18400 case OPEN:
18401 case OPERATOR:
18402 case ORGANIZATION:
18403 case OTHERS:
18404 case OVERRIDING:
18405 case PACKAGE:
18406 case PARTITION:
18407 case PRESERVE:
18408 case PRIVATE:
18409 case PROCEDURE:
18410 case RANGE:
18411 case RAW:
18412 case REAL:
18413 case RECORD:
18414 case REF:
18415 case RELEASE:
18416 case RELIES_ON:
18417 case RENAME:
18418 case RESULT:
18419 case RETURN:
18420 case RETURNING:
18421 case REVERSE:
18422 case ROLLBACK:
18423 case ROW:
18424 case ROWS:
18425 case ROWID:
18426 case ROWNUM:
18427 case SAVE:
18428 case SAVEPOINT:
18429 case SECOND:
18430 case SELECT:
18431 case SELF:
18432 case SET:
18433 case SPACE:
18434 case SQL:
18435 case SQLCODE:
18436 case SQLERRM:
18437 case STATIC:
18438 case SUBTYPE:
18439 case SUBSTITUTABLE:
18440 case SUCCESSFUL:
18441 case SYSDATE:
18442 case SYS_REFCURSOR:
18443 case TEMPORARY:
18444 case TIME:
18445 case TIMESTAMP:
18446 case TIMEZONE_REGION:
18447 case TIMEZONE_ABBR:
18448 case TIMEZONE_MINUTE:
18449 case TIMEZONE_HOUR:
18450 case TRANSACTION:
18451 case TRUE:
18452 case TYPE:
18453 case UNDER:
18454 case USING:
18455 case YES:
18456 case SHOW:
18457 case A:
18458 case DOUBLE:
18459 case DEC:
18460 case PRECISION:
18461 case INT:
18462 case NUMERIC:
18463 case NCHAR:
18464 case NVARCHAR2:
18465 case STRING:
18466 case UROWID:
18467 case VARRAY:
18468 case VARYING:
18469 case BFILE:
18470 case BLOB:
18471 case CLOB:
18472 case NCLOB:
18473 case YEAR:
18474 case LOCAL:
18475 case WITH:
18476 case ZONE:
18477 case CHARACTER:
18478 case AFTER:
18479 case BEFORE:
18480 case OLD:
18481 case PARENT:
18482 case ANALYZE:
18483 case ASSOCIATE:
18484 case AUDIT:
18485 case COMPOUND:
18486 case DATABASE:
18487 case CALL:
18488 case DDL:
18489 case DISASSOCIATE:
18490 case EACH:
18491 case FOLLOWS:
18492 case LOGOFF:
18493 case LOGON:
18494 case NESTED:
18495 case NOAUDIT:
18496 case SCHEMA:
18497 case SERVERERROR:
18498 case SHUTDOWN:
18499 case STARTUP:
18500 case STATEMENT:
18501 case STATISTICS:
18502 case SUSPEND:
18503 case TRUNCATE:
18504 case WRAPPED:
18505 case LIBRARY:
18506 case NAME:
18507 case STRUCT:
18508 case CONTEXT:
18509 case PARAMETERS:
18510 case LENGTH:
18511 case TDO:
18512 case MAXLEN:
18513 case CHARSETID:
18514 case CHARSETFORM:
18515 case ACCEPT:
18516 case ACCESSIBLE:
18517 case COPY:
18518 case DEFINE:
18519 case DISCONNECT:
18520 case HOST:
18521 case PRINT:
18522 case QUIT:
18523 case REMARK:
18524 case UNDEFINE:
18525 case VARIABLE:
18526 case WHENEVER:
18527 case ATTACH:
18528 case CAST:
18529 case TREAT:
18530 case TRIM:
18531 case LEFT:
18532 case RIGHT:
18533 case BOTH:
18534 case EMPTY:
18535 case MULTISET:
18536 case SUBMULTISET:
18537 case LEADING:
18538 case TRAILING:
18539 case CHAR_CS:
18540 case NCHAR_CS:
18541 case DBTIMEZONE:
18542 case SESSIONTIMEZONE:
18543 case AUTHENTICATED:
18544 case LINK:
18545 case SHARED:
18546 case DIRECTORY:
18547 case USER:
18548 case IDENTIFIER:
18549 case UNSIGNED_NUMERIC_LITERAL:
18550 case CHARACTER_LITERAL:
18551 case STRING_LITERAL:
18552 case QUOTED_LITERAL:
18553 simpleNode = UnaryExpressionNotPlusMinus();
18554 sb.append(simpleNode.getImage());
18555 break;
18556 default:
18557 jj_la1[252] = jj_gen;
18558 jj_consume_token(-1);
18559 throw new ParseException();
18560 }
18561 jjtree.closeNodeScope(jjtn000, true);
18562 jjtc000 = false;
18563 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18564 } catch (Throwable jjte000) {
18565 if (jjtc000) {
18566 jjtree.clearNodeScope(jjtn000);
18567 jjtc000 = false;
18568 } else {
18569 jjtree.popNode();
18570 }
18571 if (jjte000 instanceof RuntimeException) {
18572 {if (true) throw (RuntimeException)jjte000;}
18573 }
18574 if (jjte000 instanceof ParseException) {
18575 {if (true) throw (ParseException)jjte000;}
18576 }
18577 {if (true) throw (Error)jjte000;}
18578 } finally {
18579 if (jjtc000) {
18580 jjtree.closeNodeScope(jjtn000, true);
18581 }
18582 }
18583 throw new Error("Missing return statement in function");
18584 }
18585
18586 final public ASTUnaryExpressionNotPlusMinus UnaryExpressionNotPlusMinus() throws ParseException {
18587
18588 ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
18589 boolean jjtc000 = true;
18590 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18591 try {
18592 switch (jj_nt.kind) {
18593 case NOT:
18594 jj_consume_token(NOT);
18595 sb.append(" NOT ");
18596 simpleNode = UnaryExpression(false);
18597 sb.append(simpleNode.getImage());
18598 break;
18599 case 5:
18600 case REPLACE:
18601 case DEFINER:
18602 case CURRENT_USER:
18603 case LANGUAGE:
18604 case INLINE:
18605 case ADD:
18606 case AGGREGATE:
18607 case ARRAY:
18608 case AT:
18609 case ATTRIBUTE:
18610 case AUTHID:
18611 case BODY:
18612 case BULK:
18613 case BYTE:
18614 case CASCADE:
18615 case CASE:
18616 case CLOSE:
18617 case COALESCE:
18618 case COLLECT:
18619 case COLUMN:
18620 case COMMENT:
18621 case COMMIT:
18622 case CONSTRUCTOR:
18623 case CONTINUE:
18624 case CONVERT:
18625 case CURRENT:
18626 case CURSOR:
18627 case DATA:
18628 case DATE:
18629 case DAY:
18630 case DISABLE:
18631 case EDITIONABLE:
18632 case ELEMENT:
18633 case ENABLE:
18634 case ESCAPE:
18635 case EXCEPT:
18636 case EXCEPTIONS:
18637 case EXIT:
18638 case EXTERNAL:
18639 case EXTENDS:
18640 case EXTRACT:
18641 case FALSE:
18642 case FINAL:
18643 case FORCE:
18644 case FUNCTION:
18645 case GLOBAL:
18646 case HASH:
18647 case HEAP:
18648 case HOUR:
18649 case IMMEDIATE:
18650 case INDICES:
18651 case INDEXTYPE:
18652 case INDICATOR:
18653 case INSTANTIABLE:
18654 case INTERVAL:
18655 case INVALIDATE:
18656 case ISOLATION:
18657 case JAVA:
18658 case LEVEL:
18659 case LIMIT:
18660 case LOOP:
18661 case MAP:
18662 case MAX:
18663 case MEMBER:
18664 case MERGE:
18665 case MIN:
18666 case MINUTE:
18667 case MLSLABEL:
18668 case MODIFY:
18669 case MOD:
18670 case MONTH:
18671 case NATURAL:
18672 case NEW:
18673 case NEW_DOT:
18674 case NO:
18675 case NONEDITIONABLE:
18676 case NULL:
18677 case NULLIF:
18678 case OBJECT:
18679 case OID:
18680 case OPAQUE:
18681 case OPEN:
18682 case OPERATOR:
18683 case ORGANIZATION:
18684 case OTHERS:
18685 case OVERRIDING:
18686 case PACKAGE:
18687 case PARTITION:
18688 case PRESERVE:
18689 case PRIVATE:
18690 case PROCEDURE:
18691 case RANGE:
18692 case RAW:
18693 case REAL:
18694 case RECORD:
18695 case REF:
18696 case RELEASE:
18697 case RELIES_ON:
18698 case RENAME:
18699 case RESULT:
18700 case RETURN:
18701 case RETURNING:
18702 case REVERSE:
18703 case ROLLBACK:
18704 case ROW:
18705 case ROWS:
18706 case ROWID:
18707 case ROWNUM:
18708 case SAVE:
18709 case SAVEPOINT:
18710 case SECOND:
18711 case SELECT:
18712 case SELF:
18713 case SET:
18714 case SPACE:
18715 case SQL:
18716 case SQLCODE:
18717 case SQLERRM:
18718 case STATIC:
18719 case SUBTYPE:
18720 case SUBSTITUTABLE:
18721 case SUCCESSFUL:
18722 case SYSDATE:
18723 case SYS_REFCURSOR:
18724 case TEMPORARY:
18725 case TIME:
18726 case TIMESTAMP:
18727 case TIMEZONE_REGION:
18728 case TIMEZONE_ABBR:
18729 case TIMEZONE_MINUTE:
18730 case TIMEZONE_HOUR:
18731 case TRANSACTION:
18732 case TRUE:
18733 case TYPE:
18734 case UNDER:
18735 case USING:
18736 case YES:
18737 case SHOW:
18738 case A:
18739 case DOUBLE:
18740 case DEC:
18741 case PRECISION:
18742 case INT:
18743 case NUMERIC:
18744 case NCHAR:
18745 case NVARCHAR2:
18746 case STRING:
18747 case UROWID:
18748 case VARRAY:
18749 case VARYING:
18750 case BFILE:
18751 case BLOB:
18752 case CLOB:
18753 case NCLOB:
18754 case YEAR:
18755 case LOCAL:
18756 case WITH:
18757 case ZONE:
18758 case CHARACTER:
18759 case AFTER:
18760 case BEFORE:
18761 case OLD:
18762 case PARENT:
18763 case ANALYZE:
18764 case ASSOCIATE:
18765 case AUDIT:
18766 case COMPOUND:
18767 case DATABASE:
18768 case CALL:
18769 case DDL:
18770 case DISASSOCIATE:
18771 case EACH:
18772 case FOLLOWS:
18773 case LOGOFF:
18774 case LOGON:
18775 case NESTED:
18776 case NOAUDIT:
18777 case SCHEMA:
18778 case SERVERERROR:
18779 case SHUTDOWN:
18780 case STARTUP:
18781 case STATEMENT:
18782 case STATISTICS:
18783 case SUSPEND:
18784 case TRUNCATE:
18785 case WRAPPED:
18786 case LIBRARY:
18787 case NAME:
18788 case STRUCT:
18789 case CONTEXT:
18790 case PARAMETERS:
18791 case LENGTH:
18792 case TDO:
18793 case MAXLEN:
18794 case CHARSETID:
18795 case CHARSETFORM:
18796 case ACCEPT:
18797 case ACCESSIBLE:
18798 case COPY:
18799 case DEFINE:
18800 case DISCONNECT:
18801 case HOST:
18802 case PRINT:
18803 case QUIT:
18804 case REMARK:
18805 case UNDEFINE:
18806 case VARIABLE:
18807 case WHENEVER:
18808 case ATTACH:
18809 case CAST:
18810 case TREAT:
18811 case TRIM:
18812 case LEFT:
18813 case RIGHT:
18814 case BOTH:
18815 case EMPTY:
18816 case MULTISET:
18817 case SUBMULTISET:
18818 case LEADING:
18819 case TRAILING:
18820 case CHAR_CS:
18821 case NCHAR_CS:
18822 case DBTIMEZONE:
18823 case SESSIONTIMEZONE:
18824 case AUTHENTICATED:
18825 case LINK:
18826 case SHARED:
18827 case DIRECTORY:
18828 case USER:
18829 case IDENTIFIER:
18830 case UNSIGNED_NUMERIC_LITERAL:
18831 case CHARACTER_LITERAL:
18832 case STRING_LITERAL:
18833 case QUOTED_LITERAL:
18834 simpleNode = IsNullCondition();
18835 sb.append(simpleNode.getImage());
18836 break;
18837 default:
18838 jj_la1[253] = jj_gen;
18839 jj_consume_token(-1);
18840 throw new ParseException();
18841 }
18842 jjtree.closeNodeScope(jjtn000, true);
18843 jjtc000 = false;
18844 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18845 } catch (Throwable jjte000) {
18846 if (jjtc000) {
18847 jjtree.clearNodeScope(jjtn000);
18848 jjtc000 = false;
18849 } else {
18850 jjtree.popNode();
18851 }
18852 if (jjte000 instanceof RuntimeException) {
18853 {if (true) throw (RuntimeException)jjte000;}
18854 }
18855 if (jjte000 instanceof ParseException) {
18856 {if (true) throw (ParseException)jjte000;}
18857 }
18858 {if (true) throw (Error)jjte000;}
18859 } finally {
18860 if (jjtc000) {
18861 jjtree.closeNodeScope(jjtn000, true);
18862 }
18863 }
18864 throw new Error("Missing return statement in function");
18865 }
18866
18867 final public ASTIsNullCondition IsNullCondition() throws ParseException {
18868
18869 ASTIsNullCondition jjtn000 = new ASTIsNullCondition(this, JJTISNULLCONDITION);
18870 boolean jjtc000 = true;
18871 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; PLSQLNode name = null; StringBuilder sb = new StringBuilder();
18872 try {
18873 if (jj_2_46(2147483647)) {
18874 name = Name();
18875 sb.append(name.getImage());
18876 jj_consume_token(IS);
18877 sb.append(" IS");
18878 switch (jj_nt.kind) {
18879 case NOT:
18880 jj_consume_token(NOT);
18881 sb.append(" NOT");
18882 break;
18883 default:
18884 jj_la1[254] = jj_gen;
18885 ;
18886 }
18887 jj_consume_token(NULL);
18888 sb.append(" NULL");
18889 } else {
18890 switch (jj_nt.kind) {
18891 case 5:
18892 case REPLACE:
18893 case DEFINER:
18894 case CURRENT_USER:
18895 case LANGUAGE:
18896 case INLINE:
18897 case ADD:
18898 case AGGREGATE:
18899 case ARRAY:
18900 case AT:
18901 case ATTRIBUTE:
18902 case AUTHID:
18903 case BODY:
18904 case BULK:
18905 case BYTE:
18906 case CASCADE:
18907 case CASE:
18908 case CLOSE:
18909 case COALESCE:
18910 case COLLECT:
18911 case COLUMN:
18912 case COMMENT:
18913 case COMMIT:
18914 case CONSTRUCTOR:
18915 case CONTINUE:
18916 case CONVERT:
18917 case CURRENT:
18918 case CURSOR:
18919 case DATA:
18920 case DATE:
18921 case DAY:
18922 case DISABLE:
18923 case EDITIONABLE:
18924 case ELEMENT:
18925 case ENABLE:
18926 case ESCAPE:
18927 case EXCEPT:
18928 case EXCEPTIONS:
18929 case EXIT:
18930 case EXTERNAL:
18931 case EXTENDS:
18932 case EXTRACT:
18933 case FALSE:
18934 case FINAL:
18935 case FORCE:
18936 case FUNCTION:
18937 case GLOBAL:
18938 case HASH:
18939 case HEAP:
18940 case HOUR:
18941 case IMMEDIATE:
18942 case INDICES:
18943 case INDEXTYPE:
18944 case INDICATOR:
18945 case INSTANTIABLE:
18946 case INTERVAL:
18947 case INVALIDATE:
18948 case ISOLATION:
18949 case JAVA:
18950 case LEVEL:
18951 case LIMIT:
18952 case LOOP:
18953 case MAP:
18954 case MAX:
18955 case MEMBER:
18956 case MERGE:
18957 case MIN:
18958 case MINUTE:
18959 case MLSLABEL:
18960 case MODIFY:
18961 case MOD:
18962 case MONTH:
18963 case NATURAL:
18964 case NEW:
18965 case NEW_DOT:
18966 case NO:
18967 case NONEDITIONABLE:
18968 case NULL:
18969 case NULLIF:
18970 case OBJECT:
18971 case OID:
18972 case OPAQUE:
18973 case OPEN:
18974 case OPERATOR:
18975 case ORGANIZATION:
18976 case OTHERS:
18977 case OVERRIDING:
18978 case PACKAGE:
18979 case PARTITION:
18980 case PRESERVE:
18981 case PRIVATE:
18982 case PROCEDURE:
18983 case RANGE:
18984 case RAW:
18985 case REAL:
18986 case RECORD:
18987 case REF:
18988 case RELEASE:
18989 case RELIES_ON:
18990 case RENAME:
18991 case RESULT:
18992 case RETURN:
18993 case RETURNING:
18994 case REVERSE:
18995 case ROLLBACK:
18996 case ROW:
18997 case ROWS:
18998 case ROWID:
18999 case ROWNUM:
19000 case SAVE:
19001 case SAVEPOINT:
19002 case SECOND:
19003 case SELECT:
19004 case SELF:
19005 case SET:
19006 case SPACE:
19007 case SQL:
19008 case SQLCODE:
19009 case SQLERRM:
19010 case STATIC:
19011 case SUBTYPE:
19012 case SUBSTITUTABLE:
19013 case SUCCESSFUL:
19014 case SYSDATE:
19015 case SYS_REFCURSOR:
19016 case TEMPORARY:
19017 case TIME:
19018 case TIMESTAMP:
19019 case TIMEZONE_REGION:
19020 case TIMEZONE_ABBR:
19021 case TIMEZONE_MINUTE:
19022 case TIMEZONE_HOUR:
19023 case TRANSACTION:
19024 case TRUE:
19025 case TYPE:
19026 case UNDER:
19027 case USING:
19028 case YES:
19029 case SHOW:
19030 case A:
19031 case DOUBLE:
19032 case DEC:
19033 case PRECISION:
19034 case INT:
19035 case NUMERIC:
19036 case NCHAR:
19037 case NVARCHAR2:
19038 case STRING:
19039 case UROWID:
19040 case VARRAY:
19041 case VARYING:
19042 case BFILE:
19043 case BLOB:
19044 case CLOB:
19045 case NCLOB:
19046 case YEAR:
19047 case LOCAL:
19048 case WITH:
19049 case ZONE:
19050 case CHARACTER:
19051 case AFTER:
19052 case BEFORE:
19053 case OLD:
19054 case PARENT:
19055 case ANALYZE:
19056 case ASSOCIATE:
19057 case AUDIT:
19058 case COMPOUND:
19059 case DATABASE:
19060 case CALL:
19061 case DDL:
19062 case DISASSOCIATE:
19063 case EACH:
19064 case FOLLOWS:
19065 case LOGOFF:
19066 case LOGON:
19067 case NESTED:
19068 case NOAUDIT:
19069 case SCHEMA:
19070 case SERVERERROR:
19071 case SHUTDOWN:
19072 case STARTUP:
19073 case STATEMENT:
19074 case STATISTICS:
19075 case SUSPEND:
19076 case TRUNCATE:
19077 case WRAPPED:
19078 case LIBRARY:
19079 case NAME:
19080 case STRUCT:
19081 case CONTEXT:
19082 case PARAMETERS:
19083 case LENGTH:
19084 case TDO:
19085 case MAXLEN:
19086 case CHARSETID:
19087 case CHARSETFORM:
19088 case ACCEPT:
19089 case ACCESSIBLE:
19090 case COPY:
19091 case DEFINE:
19092 case DISCONNECT:
19093 case HOST:
19094 case PRINT:
19095 case QUIT:
19096 case REMARK:
19097 case UNDEFINE:
19098 case VARIABLE:
19099 case WHENEVER:
19100 case ATTACH:
19101 case CAST:
19102 case TREAT:
19103 case TRIM:
19104 case LEFT:
19105 case RIGHT:
19106 case BOTH:
19107 case EMPTY:
19108 case MULTISET:
19109 case SUBMULTISET:
19110 case LEADING:
19111 case TRAILING:
19112 case CHAR_CS:
19113 case NCHAR_CS:
19114 case DBTIMEZONE:
19115 case SESSIONTIMEZONE:
19116 case AUTHENTICATED:
19117 case LINK:
19118 case SHARED:
19119 case DIRECTORY:
19120 case USER:
19121 case IDENTIFIER:
19122 case UNSIGNED_NUMERIC_LITERAL:
19123 case CHARACTER_LITERAL:
19124 case STRING_LITERAL:
19125 case QUOTED_LITERAL:
19126 simpleNode = IsOfTypeCondition();
19127 sb.append(simpleNode.getImage());
19128 break;
19129 default:
19130 jj_la1[255] = jj_gen;
19131 jj_consume_token(-1);
19132 throw new ParseException();
19133 }
19134 }
19135 jjtree.closeNodeScope(jjtn000, true);
19136 jjtc000 = false;
19137 jjtn000.setImage(sb.toString());
19138 {if (true) return jjtn000;}
19139 } catch (Throwable jjte000) {
19140 if (jjtc000) {
19141 jjtree.clearNodeScope(jjtn000);
19142 jjtc000 = false;
19143 } else {
19144 jjtree.popNode();
19145 }
19146 if (jjte000 instanceof RuntimeException) {
19147 {if (true) throw (RuntimeException)jjte000;}
19148 }
19149 if (jjte000 instanceof ParseException) {
19150 {if (true) throw (ParseException)jjte000;}
19151 }
19152 {if (true) throw (Error)jjte000;}
19153 } finally {
19154 if (jjtc000) {
19155 jjtree.closeNodeScope(jjtn000, true);
19156 }
19157 }
19158 throw new Error("Missing return statement in function");
19159 }
19160
19161 final public ASTIsOfTypeCondition IsOfTypeCondition() throws ParseException {
19162
19163 ASTIsOfTypeCondition jjtn000 = new ASTIsOfTypeCondition(this, JJTISOFTYPECONDITION);
19164 boolean jjtc000 = true;
19165 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; PLSQLNode name = null; StringBuilder sb = new StringBuilder();
19166 try {
19167 if (jj_2_47(2147483647)) {
19168 name = Name();
19169 sb.append(name.getImage());
19170 jj_consume_token(IS);
19171 sb.append(" IS");
19172 switch (jj_nt.kind) {
19173 case NOT:
19174 jj_consume_token(NOT);
19175 sb.append(" NOT");
19176 break;
19177 default:
19178 jj_la1[256] = jj_gen;
19179 ;
19180 }
19181 jj_consume_token(OF);
19182 sb.append(" OF");
19183 switch (jj_nt.kind) {
19184 case TYPE:
19185 jj_consume_token(TYPE);
19186 break;
19187 default:
19188 jj_la1[257] = jj_gen;
19189 ;
19190 }
19191 jj_consume_token(5);
19192 switch (jj_nt.kind) {
19193 case ONLY:
19194 jj_consume_token(ONLY);
19195 break;
19196 default:
19197 jj_la1[258] = jj_gen;
19198 ;
19199 }
19200 Name();
19201 label_61:
19202 while (true) {
19203 switch (jj_nt.kind) {
19204 case 6:
19205 ;
19206 break;
19207 default:
19208 jj_la1[259] = jj_gen;
19209 break label_61;
19210 }
19211 jj_consume_token(6);
19212 switch (jj_nt.kind) {
19213 case ONLY:
19214 jj_consume_token(ONLY);
19215 break;
19216 default:
19217 jj_la1[260] = jj_gen;
19218 ;
19219 }
19220 Name();
19221 }
19222 jj_consume_token(7);
19223 } else {
19224 switch (jj_nt.kind) {
19225 case 5:
19226 case REPLACE:
19227 case DEFINER:
19228 case CURRENT_USER:
19229 case LANGUAGE:
19230 case INLINE:
19231 case ADD:
19232 case AGGREGATE:
19233 case ARRAY:
19234 case AT:
19235 case ATTRIBUTE:
19236 case AUTHID:
19237 case BODY:
19238 case BULK:
19239 case BYTE:
19240 case CASCADE:
19241 case CASE:
19242 case CLOSE:
19243 case COALESCE:
19244 case COLLECT:
19245 case COLUMN:
19246 case COMMENT:
19247 case COMMIT:
19248 case CONSTRUCTOR:
19249 case CONTINUE:
19250 case CONVERT:
19251 case CURRENT:
19252 case CURSOR:
19253 case DATA:
19254 case DATE:
19255 case DAY:
19256 case DISABLE:
19257 case EDITIONABLE:
19258 case ELEMENT:
19259 case ENABLE:
19260 case ESCAPE:
19261 case EXCEPT:
19262 case EXCEPTIONS:
19263 case EXIT:
19264 case EXTERNAL:
19265 case EXTENDS:
19266 case EXTRACT:
19267 case FALSE:
19268 case FINAL:
19269 case FORCE:
19270 case FUNCTION:
19271 case GLOBAL:
19272 case HASH:
19273 case HEAP:
19274 case HOUR:
19275 case IMMEDIATE:
19276 case INDICES:
19277 case INDEXTYPE:
19278 case INDICATOR:
19279 case INSTANTIABLE:
19280 case INTERVAL:
19281 case INVALIDATE:
19282 case ISOLATION:
19283 case JAVA:
19284 case LEVEL:
19285 case LIMIT:
19286 case LOOP:
19287 case MAP:
19288 case MAX:
19289 case MEMBER:
19290 case MERGE:
19291 case MIN:
19292 case MINUTE:
19293 case MLSLABEL:
19294 case MODIFY:
19295 case MOD:
19296 case MONTH:
19297 case NATURAL:
19298 case NEW:
19299 case NEW_DOT:
19300 case NO:
19301 case NONEDITIONABLE:
19302 case NULL:
19303 case NULLIF:
19304 case OBJECT:
19305 case OID:
19306 case OPAQUE:
19307 case OPEN:
19308 case OPERATOR:
19309 case ORGANIZATION:
19310 case OTHERS:
19311 case OVERRIDING:
19312 case PACKAGE:
19313 case PARTITION:
19314 case PRESERVE:
19315 case PRIVATE:
19316 case PROCEDURE:
19317 case RANGE:
19318 case RAW:
19319 case REAL:
19320 case RECORD:
19321 case REF:
19322 case RELEASE:
19323 case RELIES_ON:
19324 case RENAME:
19325 case RESULT:
19326 case RETURN:
19327 case RETURNING:
19328 case REVERSE:
19329 case ROLLBACK:
19330 case ROW:
19331 case ROWS:
19332 case ROWID:
19333 case ROWNUM:
19334 case SAVE:
19335 case SAVEPOINT:
19336 case SECOND:
19337 case SELECT:
19338 case SELF:
19339 case SET:
19340 case SPACE:
19341 case SQL:
19342 case SQLCODE:
19343 case SQLERRM:
19344 case STATIC:
19345 case SUBTYPE:
19346 case SUBSTITUTABLE:
19347 case SUCCESSFUL:
19348 case SYSDATE:
19349 case SYS_REFCURSOR:
19350 case TEMPORARY:
19351 case TIME:
19352 case TIMESTAMP:
19353 case TIMEZONE_REGION:
19354 case TIMEZONE_ABBR:
19355 case TIMEZONE_MINUTE:
19356 case TIMEZONE_HOUR:
19357 case TRANSACTION:
19358 case TRUE:
19359 case TYPE:
19360 case UNDER:
19361 case USING:
19362 case YES:
19363 case SHOW:
19364 case A:
19365 case DOUBLE:
19366 case DEC:
19367 case PRECISION:
19368 case INT:
19369 case NUMERIC:
19370 case NCHAR:
19371 case NVARCHAR2:
19372 case STRING:
19373 case UROWID:
19374 case VARRAY:
19375 case VARYING:
19376 case BFILE:
19377 case BLOB:
19378 case CLOB:
19379 case NCLOB:
19380 case YEAR:
19381 case LOCAL:
19382 case WITH:
19383 case ZONE:
19384 case CHARACTER:
19385 case AFTER:
19386 case BEFORE:
19387 case OLD:
19388 case PARENT:
19389 case ANALYZE:
19390 case ASSOCIATE:
19391 case AUDIT:
19392 case COMPOUND:
19393 case DATABASE:
19394 case CALL:
19395 case DDL:
19396 case DISASSOCIATE:
19397 case EACH:
19398 case FOLLOWS:
19399 case LOGOFF:
19400 case LOGON:
19401 case NESTED:
19402 case NOAUDIT:
19403 case SCHEMA:
19404 case SERVERERROR:
19405 case SHUTDOWN:
19406 case STARTUP:
19407 case STATEMENT:
19408 case STATISTICS:
19409 case SUSPEND:
19410 case TRUNCATE:
19411 case WRAPPED:
19412 case LIBRARY:
19413 case NAME:
19414 case STRUCT:
19415 case CONTEXT:
19416 case PARAMETERS:
19417 case LENGTH:
19418 case TDO:
19419 case MAXLEN:
19420 case CHARSETID:
19421 case CHARSETFORM:
19422 case ACCEPT:
19423 case ACCESSIBLE:
19424 case COPY:
19425 case DEFINE:
19426 case DISCONNECT:
19427 case HOST:
19428 case PRINT:
19429 case QUIT:
19430 case REMARK:
19431 case UNDEFINE:
19432 case VARIABLE:
19433 case WHENEVER:
19434 case ATTACH:
19435 case CAST:
19436 case TREAT:
19437 case TRIM:
19438 case LEFT:
19439 case RIGHT:
19440 case BOTH:
19441 case EMPTY:
19442 case MULTISET:
19443 case SUBMULTISET:
19444 case LEADING:
19445 case TRAILING:
19446 case CHAR_CS:
19447 case NCHAR_CS:
19448 case DBTIMEZONE:
19449 case SESSIONTIMEZONE:
19450 case AUTHENTICATED:
19451 case LINK:
19452 case SHARED:
19453 case DIRECTORY:
19454 case USER:
19455 case IDENTIFIER:
19456 case UNSIGNED_NUMERIC_LITERAL:
19457 case CHARACTER_LITERAL:
19458 case STRING_LITERAL:
19459 case QUOTED_LITERAL:
19460 simpleNode = PrimaryExpression();
19461 sb.append(simpleNode.getImage());
19462 break;
19463 default:
19464 jj_la1[261] = jj_gen;
19465 jj_consume_token(-1);
19466 throw new ParseException();
19467 }
19468 }
19469 jjtree.closeNodeScope(jjtn000, true);
19470 jjtc000 = false;
19471 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19472 } catch (Throwable jjte000) {
19473 if (jjtc000) {
19474 jjtree.clearNodeScope(jjtn000);
19475 jjtc000 = false;
19476 } else {
19477 jjtree.popNode();
19478 }
19479 if (jjte000 instanceof RuntimeException) {
19480 {if (true) throw (RuntimeException)jjte000;}
19481 }
19482 if (jjte000 instanceof ParseException) {
19483 {if (true) throw (ParseException)jjte000;}
19484 }
19485 {if (true) throw (Error)jjte000;}
19486 } finally {
19487 if (jjtc000) {
19488 jjtree.closeNodeScope(jjtn000, true);
19489 }
19490 }
19491 throw new Error("Missing return statement in function");
19492 }
19493
19494
19495
19496
19497
19498
19499 final public ASTPrimaryExpression PrimaryExpression() throws ParseException {
19500
19501 ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
19502 boolean jjtc000 = true;
19503 jjtree.openNodeScope(jjtn000);Token thisToken ; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
19504 try {
19505 switch (jj_nt.kind) {
19506 case NEW_DOT:
19507 jj_consume_token(NEW_DOT);
19508 simpleNode = QualifiedID();
19509 sb.append(" NEW."); sb.append(simpleNode.getImage());
19510 break;
19511 case 5:
19512 case REPLACE:
19513 case DEFINER:
19514 case CURRENT_USER:
19515 case LANGUAGE:
19516 case INLINE:
19517 case ADD:
19518 case AGGREGATE:
19519 case ARRAY:
19520 case AT:
19521 case ATTRIBUTE:
19522 case AUTHID:
19523 case BODY:
19524 case BULK:
19525 case BYTE:
19526 case CASCADE:
19527 case CASE:
19528 case CLOSE:
19529 case COALESCE:
19530 case COLLECT:
19531 case COLUMN:
19532 case COMMENT:
19533 case COMMIT:
19534 case CONSTRUCTOR:
19535 case CONTINUE:
19536 case CONVERT:
19537 case CURRENT:
19538 case CURSOR:
19539 case DATA:
19540 case DATE:
19541 case DAY:
19542 case DISABLE:
19543 case EDITIONABLE:
19544 case ELEMENT:
19545 case ENABLE:
19546 case ESCAPE:
19547 case EXCEPT:
19548 case EXCEPTIONS:
19549 case EXIT:
19550 case EXTERNAL:
19551 case EXTENDS:
19552 case EXTRACT:
19553 case FALSE:
19554 case FINAL:
19555 case FORCE:
19556 case FUNCTION:
19557 case GLOBAL:
19558 case HASH:
19559 case HEAP:
19560 case HOUR:
19561 case IMMEDIATE:
19562 case INDICES:
19563 case INDEXTYPE:
19564 case INDICATOR:
19565 case INSTANTIABLE:
19566 case INTERVAL:
19567 case INVALIDATE:
19568 case ISOLATION:
19569 case JAVA:
19570 case LEVEL:
19571 case LIMIT:
19572 case LOOP:
19573 case MAP:
19574 case MAX:
19575 case MEMBER:
19576 case MERGE:
19577 case MIN:
19578 case MINUTE:
19579 case MLSLABEL:
19580 case MODIFY:
19581 case MOD:
19582 case MONTH:
19583 case NATURAL:
19584 case NEW:
19585 case NO:
19586 case NONEDITIONABLE:
19587 case NULL:
19588 case NULLIF:
19589 case OBJECT:
19590 case OID:
19591 case OPAQUE:
19592 case OPEN:
19593 case OPERATOR:
19594 case ORGANIZATION:
19595 case OTHERS:
19596 case OVERRIDING:
19597 case PACKAGE:
19598 case PARTITION:
19599 case PRESERVE:
19600 case PRIVATE:
19601 case PROCEDURE:
19602 case RANGE:
19603 case RAW:
19604 case REAL:
19605 case RECORD:
19606 case REF:
19607 case RELEASE:
19608 case RELIES_ON:
19609 case RENAME:
19610 case RESULT:
19611 case RETURN:
19612 case RETURNING:
19613 case REVERSE:
19614 case ROLLBACK:
19615 case ROW:
19616 case ROWS:
19617 case ROWID:
19618 case ROWNUM:
19619 case SAVE:
19620 case SAVEPOINT:
19621 case SECOND:
19622 case SELECT:
19623 case SELF:
19624 case SET:
19625 case SPACE:
19626 case SQL:
19627 case SQLCODE:
19628 case SQLERRM:
19629 case STATIC:
19630 case SUBTYPE:
19631 case SUBSTITUTABLE:
19632 case SUCCESSFUL:
19633 case SYSDATE:
19634 case SYS_REFCURSOR:
19635 case TEMPORARY:
19636 case TIME:
19637 case TIMESTAMP:
19638 case TIMEZONE_REGION:
19639 case TIMEZONE_ABBR:
19640 case TIMEZONE_MINUTE:
19641 case TIMEZONE_HOUR:
19642 case TRANSACTION:
19643 case TRUE:
19644 case TYPE:
19645 case UNDER:
19646 case USING:
19647 case YES:
19648 case SHOW:
19649 case A:
19650 case DOUBLE:
19651 case DEC:
19652 case PRECISION:
19653 case INT:
19654 case NUMERIC:
19655 case NCHAR:
19656 case NVARCHAR2:
19657 case STRING:
19658 case UROWID:
19659 case VARRAY:
19660 case VARYING:
19661 case BFILE:
19662 case BLOB:
19663 case CLOB:
19664 case NCLOB:
19665 case YEAR:
19666 case LOCAL:
19667 case WITH:
19668 case ZONE:
19669 case CHARACTER:
19670 case AFTER:
19671 case BEFORE:
19672 case OLD:
19673 case PARENT:
19674 case ANALYZE:
19675 case ASSOCIATE:
19676 case AUDIT:
19677 case COMPOUND:
19678 case DATABASE:
19679 case CALL:
19680 case DDL:
19681 case DISASSOCIATE:
19682 case EACH:
19683 case FOLLOWS:
19684 case LOGOFF:
19685 case LOGON:
19686 case NESTED:
19687 case NOAUDIT:
19688 case SCHEMA:
19689 case SERVERERROR:
19690 case SHUTDOWN:
19691 case STARTUP:
19692 case STATEMENT:
19693 case STATISTICS:
19694 case SUSPEND:
19695 case TRUNCATE:
19696 case WRAPPED:
19697 case LIBRARY:
19698 case NAME:
19699 case STRUCT:
19700 case CONTEXT:
19701 case PARAMETERS:
19702 case LENGTH:
19703 case TDO:
19704 case MAXLEN:
19705 case CHARSETID:
19706 case CHARSETFORM:
19707 case ACCEPT:
19708 case ACCESSIBLE:
19709 case COPY:
19710 case DEFINE:
19711 case DISCONNECT:
19712 case HOST:
19713 case PRINT:
19714 case QUIT:
19715 case REMARK:
19716 case UNDEFINE:
19717 case VARIABLE:
19718 case WHENEVER:
19719 case ATTACH:
19720 case CAST:
19721 case TREAT:
19722 case TRIM:
19723 case LEFT:
19724 case RIGHT:
19725 case BOTH:
19726 case EMPTY:
19727 case MULTISET:
19728 case SUBMULTISET:
19729 case LEADING:
19730 case TRAILING:
19731 case CHAR_CS:
19732 case NCHAR_CS:
19733 case DBTIMEZONE:
19734 case SESSIONTIMEZONE:
19735 case AUTHENTICATED:
19736 case LINK:
19737 case SHARED:
19738 case DIRECTORY:
19739 case USER:
19740 case IDENTIFIER:
19741 case UNSIGNED_NUMERIC_LITERAL:
19742 case CHARACTER_LITERAL:
19743 case STRING_LITERAL:
19744 case QUOTED_LITERAL:
19745 if (jj_2_48(2147483647)) {
19746 jj_consume_token(NEW);
19747 sb.append(" NEW ");
19748 simpleNode = PrimaryPrefix();
19749 sb.append(simpleNode.getImage());
19750 } else {
19751 switch (jj_nt.kind) {
19752 case 5:
19753 case REPLACE:
19754 case DEFINER:
19755 case CURRENT_USER:
19756 case LANGUAGE:
19757 case INLINE:
19758 case ADD:
19759 case AGGREGATE:
19760 case ARRAY:
19761 case AT:
19762 case ATTRIBUTE:
19763 case AUTHID:
19764 case BODY:
19765 case BULK:
19766 case BYTE:
19767 case CASCADE:
19768 case CASE:
19769 case CLOSE:
19770 case COALESCE:
19771 case COLLECT:
19772 case COLUMN:
19773 case COMMENT:
19774 case COMMIT:
19775 case CONSTRUCTOR:
19776 case CONTINUE:
19777 case CONVERT:
19778 case CURRENT:
19779 case CURSOR:
19780 case DATA:
19781 case DATE:
19782 case DAY:
19783 case DISABLE:
19784 case EDITIONABLE:
19785 case ELEMENT:
19786 case ENABLE:
19787 case ESCAPE:
19788 case EXCEPT:
19789 case EXCEPTIONS:
19790 case EXIT:
19791 case EXTERNAL:
19792 case EXTENDS:
19793 case EXTRACT:
19794 case FALSE:
19795 case FINAL:
19796 case FORCE:
19797 case FUNCTION:
19798 case GLOBAL:
19799 case HASH:
19800 case HEAP:
19801 case HOUR:
19802 case IMMEDIATE:
19803 case INDICES:
19804 case INDEXTYPE:
19805 case INDICATOR:
19806 case INSTANTIABLE:
19807 case INTERVAL:
19808 case INVALIDATE:
19809 case ISOLATION:
19810 case JAVA:
19811 case LEVEL:
19812 case LIMIT:
19813 case LOOP:
19814 case MAP:
19815 case MAX:
19816 case MEMBER:
19817 case MERGE:
19818 case MIN:
19819 case MINUTE:
19820 case MLSLABEL:
19821 case MODIFY:
19822 case MOD:
19823 case MONTH:
19824 case NATURAL:
19825 case NEW:
19826 case NO:
19827 case NONEDITIONABLE:
19828 case NULL:
19829 case NULLIF:
19830 case OBJECT:
19831 case OID:
19832 case OPAQUE:
19833 case OPEN:
19834 case OPERATOR:
19835 case ORGANIZATION:
19836 case OTHERS:
19837 case OVERRIDING:
19838 case PACKAGE:
19839 case PARTITION:
19840 case PRESERVE:
19841 case PRIVATE:
19842 case PROCEDURE:
19843 case RANGE:
19844 case RAW:
19845 case REAL:
19846 case RECORD:
19847 case REF:
19848 case RELEASE:
19849 case RELIES_ON:
19850 case RENAME:
19851 case RESULT:
19852 case RETURN:
19853 case RETURNING:
19854 case REVERSE:
19855 case ROLLBACK:
19856 case ROW:
19857 case ROWS:
19858 case ROWID:
19859 case ROWNUM:
19860 case SAVE:
19861 case SAVEPOINT:
19862 case SECOND:
19863 case SELECT:
19864 case SELF:
19865 case SET:
19866 case SPACE:
19867 case SQL:
19868 case SQLCODE:
19869 case SQLERRM:
19870 case STATIC:
19871 case SUBTYPE:
19872 case SUBSTITUTABLE:
19873 case SUCCESSFUL:
19874 case SYSDATE:
19875 case SYS_REFCURSOR:
19876 case TEMPORARY:
19877 case TIME:
19878 case TIMESTAMP:
19879 case TIMEZONE_REGION:
19880 case TIMEZONE_ABBR:
19881 case TIMEZONE_MINUTE:
19882 case TIMEZONE_HOUR:
19883 case TRANSACTION:
19884 case TRUE:
19885 case TYPE:
19886 case UNDER:
19887 case USING:
19888 case YES:
19889 case SHOW:
19890 case A:
19891 case DOUBLE:
19892 case DEC:
19893 case PRECISION:
19894 case INT:
19895 case NUMERIC:
19896 case NCHAR:
19897 case NVARCHAR2:
19898 case STRING:
19899 case UROWID:
19900 case VARRAY:
19901 case VARYING:
19902 case BFILE:
19903 case BLOB:
19904 case CLOB:
19905 case NCLOB:
19906 case YEAR:
19907 case LOCAL:
19908 case WITH:
19909 case ZONE:
19910 case CHARACTER:
19911 case AFTER:
19912 case BEFORE:
19913 case OLD:
19914 case PARENT:
19915 case ANALYZE:
19916 case ASSOCIATE:
19917 case AUDIT:
19918 case COMPOUND:
19919 case DATABASE:
19920 case CALL:
19921 case DDL:
19922 case DISASSOCIATE:
19923 case EACH:
19924 case FOLLOWS:
19925 case LOGOFF:
19926 case LOGON:
19927 case NESTED:
19928 case NOAUDIT:
19929 case SCHEMA:
19930 case SERVERERROR:
19931 case SHUTDOWN:
19932 case STARTUP:
19933 case STATEMENT:
19934 case STATISTICS:
19935 case SUSPEND:
19936 case TRUNCATE:
19937 case WRAPPED:
19938 case LIBRARY:
19939 case NAME:
19940 case STRUCT:
19941 case CONTEXT:
19942 case PARAMETERS:
19943 case LENGTH:
19944 case TDO:
19945 case MAXLEN:
19946 case CHARSETID:
19947 case CHARSETFORM:
19948 case ACCEPT:
19949 case ACCESSIBLE:
19950 case COPY:
19951 case DEFINE:
19952 case DISCONNECT:
19953 case HOST:
19954 case PRINT:
19955 case QUIT:
19956 case REMARK:
19957 case UNDEFINE:
19958 case VARIABLE:
19959 case WHENEVER:
19960 case ATTACH:
19961 case CAST:
19962 case TREAT:
19963 case TRIM:
19964 case LEFT:
19965 case RIGHT:
19966 case BOTH:
19967 case EMPTY:
19968 case MULTISET:
19969 case SUBMULTISET:
19970 case LEADING:
19971 case TRAILING:
19972 case CHAR_CS:
19973 case NCHAR_CS:
19974 case DBTIMEZONE:
19975 case SESSIONTIMEZONE:
19976 case AUTHENTICATED:
19977 case LINK:
19978 case SHARED:
19979 case DIRECTORY:
19980 case USER:
19981 case IDENTIFIER:
19982 case UNSIGNED_NUMERIC_LITERAL:
19983 case CHARACTER_LITERAL:
19984 case STRING_LITERAL:
19985 case QUOTED_LITERAL:
19986 simpleNode = PrimaryPrefix();
19987 sb.append(simpleNode.getImage());
19988 break;
19989 default:
19990 jj_la1[262] = jj_gen;
19991 jj_consume_token(-1);
19992 throw new ParseException();
19993 }
19994 }
19995 label_62:
19996 while (true) {
19997 if (jj_2_49(2)) {
19998 ;
19999 } else {
20000 break label_62;
20001 }
20002 simpleNode = PrimarySuffix();
20003 sb.append(simpleNode.getImage());
20004 }
20005 break;
20006 default:
20007 jj_la1[263] = jj_gen;
20008 jj_consume_token(-1);
20009 throw new ParseException();
20010 }
20011 jjtree.closeNodeScope(jjtn000, true);
20012 jjtc000 = false;
20013 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20014 } catch (Throwable jjte000) {
20015 if (jjtc000) {
20016 jjtree.clearNodeScope(jjtn000);
20017 jjtc000 = false;
20018 } else {
20019 jjtree.popNode();
20020 }
20021 if (jjte000 instanceof RuntimeException) {
20022 {if (true) throw (RuntimeException)jjte000;}
20023 }
20024 if (jjte000 instanceof ParseException) {
20025 {if (true) throw (ParseException)jjte000;}
20026 }
20027 {if (true) throw (Error)jjte000;}
20028 } finally {
20029 if (jjtc000) {
20030 jjtree.closeNodeScope(jjtn000, true);
20031 }
20032 }
20033 throw new Error("Missing return statement in function");
20034 }
20035
20036 final public ASTPrimaryPrefix PrimaryPrefix() throws ParseException {
20037
20038 ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
20039 boolean jjtc000 = true;
20040 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
20041 try {
20042 switch (jj_nt.kind) {
20043 case DATE:
20044 case FALSE:
20045 case INTERVAL:
20046 case NULL:
20047 case TIMESTAMP:
20048 case TRUE:
20049 case UNSIGNED_NUMERIC_LITERAL:
20050 case CHARACTER_LITERAL:
20051 case STRING_LITERAL:
20052 simpleNode = Literal();
20053 sb.append(simpleNode.getImage()) ;
20054 break;
20055 default:
20056 jj_la1[265] = jj_gen;
20057 if (jj_2_50(2147483647)) {
20058 simpleNode = MultiSetCondition();
20059 } else if (jj_2_51(2147483647)) {
20060 simpleNode = TrimExpression();
20061 } else if (jj_2_52(2147483647)) {
20062 simpleNode = CaseExpression();
20063 sb.append(simpleNode.getImage()) ;
20064 } else if (jj_2_53(2147483647)) {
20065 simpleNode = ObjectExpression();
20066 sb.append(simpleNode.getImage()) ;
20067 } else {
20068 switch (jj_nt.kind) {
20069 case REPLACE:
20070 case DEFINER:
20071 case CURRENT_USER:
20072 case LANGUAGE:
20073 case INLINE:
20074 case ADD:
20075 case AGGREGATE:
20076 case ARRAY:
20077 case AT:
20078 case ATTRIBUTE:
20079 case AUTHID:
20080 case BODY:
20081 case BULK:
20082 case BYTE:
20083 case CASCADE:
20084 case CLOSE:
20085 case COALESCE:
20086 case COLLECT:
20087 case COLUMN:
20088 case COMMENT:
20089 case COMMIT:
20090 case CONSTRUCTOR:
20091 case CONTINUE:
20092 case CONVERT:
20093 case CURRENT:
20094 case CURSOR:
20095 case DATA:
20096 case DAY:
20097 case DISABLE:
20098 case EDITIONABLE:
20099 case ELEMENT:
20100 case ENABLE:
20101 case ESCAPE:
20102 case EXCEPT:
20103 case EXCEPTIONS:
20104 case EXIT:
20105 case EXTERNAL:
20106 case EXTENDS:
20107 case EXTRACT:
20108 case FALSE:
20109 case FINAL:
20110 case FORCE:
20111 case FUNCTION:
20112 case GLOBAL:
20113 case HASH:
20114 case HEAP:
20115 case HOUR:
20116 case IMMEDIATE:
20117 case INDICES:
20118 case INDEXTYPE:
20119 case INDICATOR:
20120 case INSTANTIABLE:
20121 case INTERVAL:
20122 case INVALIDATE:
20123 case ISOLATION:
20124 case JAVA:
20125 case LEVEL:
20126 case LIMIT:
20127 case LOOP:
20128 case MAP:
20129 case MAX:
20130 case MEMBER:
20131 case MERGE:
20132 case MIN:
20133 case MINUTE:
20134 case MLSLABEL:
20135 case MODIFY:
20136 case MOD:
20137 case MONTH:
20138 case NATURAL:
20139 case NEW:
20140 case NO:
20141 case NONEDITIONABLE:
20142 case NULLIF:
20143 case OBJECT:
20144 case OID:
20145 case OPAQUE:
20146 case OPEN:
20147 case OPERATOR:
20148 case ORGANIZATION:
20149 case OTHERS:
20150 case OVERRIDING:
20151 case PACKAGE:
20152 case PARTITION:
20153 case PRESERVE:
20154 case PRIVATE:
20155 case PROCEDURE:
20156 case RANGE:
20157 case RAW:
20158 case REAL:
20159 case RECORD:
20160 case REF:
20161 case RELEASE:
20162 case RELIES_ON:
20163 case RENAME:
20164 case RESULT:
20165 case RETURN:
20166 case RETURNING:
20167 case REVERSE:
20168 case ROLLBACK:
20169 case ROW:
20170 case ROWS:
20171 case ROWID:
20172 case ROWNUM:
20173 case SAVE:
20174 case SAVEPOINT:
20175 case SECOND:
20176 case SELF:
20177 case SET:
20178 case SPACE:
20179 case SQL:
20180 case SQLCODE:
20181 case SQLERRM:
20182 case STATIC:
20183 case SUBTYPE:
20184 case SUBSTITUTABLE:
20185 case SUCCESSFUL:
20186 case SYSDATE:
20187 case SYS_REFCURSOR:
20188 case TEMPORARY:
20189 case TIME:
20190 case TIMESTAMP:
20191 case TIMEZONE_REGION:
20192 case TIMEZONE_ABBR:
20193 case TIMEZONE_MINUTE:
20194 case TIMEZONE_HOUR:
20195 case TRANSACTION:
20196 case TRUE:
20197 case TYPE:
20198 case UNDER:
20199 case USING:
20200 case YES:
20201 case SHOW:
20202 case A:
20203 case DOUBLE:
20204 case DEC:
20205 case PRECISION:
20206 case INT:
20207 case NUMERIC:
20208 case NCHAR:
20209 case NVARCHAR2:
20210 case STRING:
20211 case UROWID:
20212 case VARRAY:
20213 case VARYING:
20214 case BFILE:
20215 case BLOB:
20216 case CLOB:
20217 case NCLOB:
20218 case YEAR:
20219 case LOCAL:
20220 case ZONE:
20221 case CHARACTER:
20222 case AFTER:
20223 case BEFORE:
20224 case OLD:
20225 case PARENT:
20226 case ANALYZE:
20227 case ASSOCIATE:
20228 case AUDIT:
20229 case COMPOUND:
20230 case DATABASE:
20231 case CALL:
20232 case DDL:
20233 case DISASSOCIATE:
20234 case EACH:
20235 case FOLLOWS:
20236 case LOGOFF:
20237 case LOGON:
20238 case NESTED:
20239 case NOAUDIT:
20240 case SCHEMA:
20241 case SERVERERROR:
20242 case SHUTDOWN:
20243 case STARTUP:
20244 case STATEMENT:
20245 case STATISTICS:
20246 case SUSPEND:
20247 case TRUNCATE:
20248 case WRAPPED:
20249 case LIBRARY:
20250 case NAME:
20251 case STRUCT:
20252 case CONTEXT:
20253 case PARAMETERS:
20254 case LENGTH:
20255 case TDO:
20256 case MAXLEN:
20257 case CHARSETID:
20258 case CHARSETFORM:
20259 case ACCEPT:
20260 case ACCESSIBLE:
20261 case COPY:
20262 case DEFINE:
20263 case DISCONNECT:
20264 case HOST:
20265 case PRINT:
20266 case QUIT:
20267 case REMARK:
20268 case UNDEFINE:
20269 case VARIABLE:
20270 case WHENEVER:
20271 case ATTACH:
20272 case CAST:
20273 case TREAT:
20274 case TRIM:
20275 case LEFT:
20276 case RIGHT:
20277 case BOTH:
20278 case EMPTY:
20279 case MULTISET:
20280 case SUBMULTISET:
20281 case LEADING:
20282 case TRAILING:
20283 case CHAR_CS:
20284 case NCHAR_CS:
20285 case DBTIMEZONE:
20286 case SESSIONTIMEZONE:
20287 case AUTHENTICATED:
20288 case LINK:
20289 case SHARED:
20290 case DIRECTORY:
20291 case USER:
20292 case IDENTIFIER:
20293 case QUOTED_LITERAL:
20294 simpleNode = Name();
20295 sb.append(simpleNode.getImage()) ;
20296 break;
20297 default:
20298 jj_la1[266] = jj_gen;
20299 if (jj_2_54(2147483647)) {
20300 jj_consume_token(SELECT);
20301 sb.append("SELECT ...");
20302 Skip2NextTerminator(null,";");
20303 } else if (jj_2_55(2147483647)) {
20304 jj_consume_token(5);
20305 sb.append("(SELECT ...");
20306 Skip2NextTerminator("(",")");
20307 jj_consume_token(7);
20308 } else if (jj_2_56(2147483647)) {
20309 jj_consume_token(WITH);
20310 sb.append("WITH ...");
20311 Skip2NextTerminator(null,";");
20312 } else if (jj_2_57(2147483647)) {
20313 jj_consume_token(5);
20314 sb.append("(WITH ...");
20315 Skip2NextTerminator("(",")");
20316 jj_consume_token(7);
20317 } else {
20318 switch (jj_nt.kind) {
20319 case 5:
20320 jj_consume_token(5);
20321 sb.append("(");
20322 simpleNode = Expression();
20323 sb.append(simpleNode.getImage());
20324 label_63:
20325 while (true) {
20326 switch (jj_nt.kind) {
20327 case 6:
20328 ;
20329 break;
20330 default:
20331 jj_la1[264] = jj_gen;
20332 break label_63;
20333 }
20334 jj_consume_token(6);
20335 sb.append(", ");
20336 simpleNode = Expression();
20337 sb.append(simpleNode.getImage());
20338 }
20339 jj_consume_token(7);
20340 sb.append(")");
20341 break;
20342 default:
20343 jj_la1[267] = jj_gen;
20344 jj_consume_token(-1);
20345 throw new ParseException();
20346 }
20347 }
20348 }
20349 }
20350 }
20351 jjtree.closeNodeScope(jjtn000, true);
20352 jjtc000 = false;
20353 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20354 } catch (Throwable jjte000) {
20355 if (jjtc000) {
20356 jjtree.clearNodeScope(jjtn000);
20357 jjtc000 = false;
20358 } else {
20359 jjtree.popNode();
20360 }
20361 if (jjte000 instanceof RuntimeException) {
20362 {if (true) throw (RuntimeException)jjte000;}
20363 }
20364 if (jjte000 instanceof ParseException) {
20365 {if (true) throw (ParseException)jjte000;}
20366 }
20367 {if (true) throw (Error)jjte000;}
20368 } finally {
20369 if (jjtc000) {
20370 jjtree.closeNodeScope(jjtn000, true);
20371 }
20372 }
20373 throw new Error("Missing return statement in function");
20374 }
20375
20376 final public ASTPrimarySuffix PrimarySuffix() throws ParseException {
20377
20378 ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
20379 boolean jjtc000 = true;
20380 jjtree.openNodeScope(jjtn000);PLSQLNode suffixNode = null ; PLSQLNode arguments = null; StringBuilder sb = new StringBuilder() ;
20381 try {
20382 switch (jj_nt.kind) {
20383 case 3:
20384 jj_consume_token(3);
20385 sb.append(".");
20386 suffixNode = QualifiedID();
20387 sb.append(suffixNode.toString()) ;
20388 break;
20389 case 2:
20390 jj_consume_token(2);
20391 sb.append("@");
20392 suffixNode = QualifiedID();
20393 sb.append(suffixNode.toString()) ;
20394 break;
20395 case AT:
20396 jj_consume_token(AT);
20397 sb.append(" "); sb.append(token.image.toUpperCase());
20398 switch (jj_nt.kind) {
20399 case LOCAL:
20400 jj_consume_token(LOCAL);
20401 sb.append(" "); sb.append(token.image.toUpperCase());
20402 break;
20403 case TIME:
20404 jj_consume_token(TIME);
20405 jj_consume_token(ZONE);
20406 sb.append(" TIME ZONE");
20407 switch (jj_nt.kind) {
20408 case DBTIMEZONE:
20409 jj_consume_token(DBTIMEZONE);
20410 sb.append(" "); sb.append(token.image.toUpperCase());
20411 break;
20412 case SESSIONTIMEZONE:
20413 jj_consume_token(SESSIONTIMEZONE);
20414 sb.append(" "); sb.append(token.image.toUpperCase());
20415 break;
20416 case STRING_LITERAL:
20417 suffixNode = StringLiteral();
20418 sb.append(" "); sb.append(suffixNode.toString());
20419 break;
20420 case 5:
20421 case 16:
20422 case 17:
20423 case REPLACE:
20424 case DEFINER:
20425 case CURRENT_USER:
20426 case LANGUAGE:
20427 case INLINE:
20428 case ADD:
20429 case AGGREGATE:
20430 case ARRAY:
20431 case AT:
20432 case ATTRIBUTE:
20433 case AUTHID:
20434 case BODY:
20435 case BULK:
20436 case BYTE:
20437 case CASCADE:
20438 case CASE:
20439 case CLOSE:
20440 case COALESCE:
20441 case COLLECT:
20442 case COLUMN:
20443 case COMMENT:
20444 case COMMIT:
20445 case CONSTRUCTOR:
20446 case CONTINUE:
20447 case CONVERT:
20448 case CURRENT:
20449 case CURSOR:
20450 case DATA:
20451 case DATE:
20452 case DAY:
20453 case DISABLE:
20454 case EDITIONABLE:
20455 case ELEMENT:
20456 case ENABLE:
20457 case ESCAPE:
20458 case EXCEPT:
20459 case EXCEPTIONS:
20460 case EXIT:
20461 case EXTERNAL:
20462 case EXTENDS:
20463 case EXTRACT:
20464 case FALSE:
20465 case FINAL:
20466 case FORCE:
20467 case FUNCTION:
20468 case GLOBAL:
20469 case HASH:
20470 case HEAP:
20471 case HOUR:
20472 case IMMEDIATE:
20473 case INDICES:
20474 case INDEXTYPE:
20475 case INDICATOR:
20476 case INSTANTIABLE:
20477 case INTERVAL:
20478 case INVALIDATE:
20479 case ISOLATION:
20480 case JAVA:
20481 case LEVEL:
20482 case LIMIT:
20483 case LOOP:
20484 case MAP:
20485 case MAX:
20486 case MEMBER:
20487 case MERGE:
20488 case MIN:
20489 case MINUTE:
20490 case MLSLABEL:
20491 case MODIFY:
20492 case MOD:
20493 case MONTH:
20494 case NATURAL:
20495 case NEW:
20496 case NEW_DOT:
20497 case NO:
20498 case NONEDITIONABLE:
20499 case NOT:
20500 case NULL:
20501 case NULLIF:
20502 case OBJECT:
20503 case OID:
20504 case OPAQUE:
20505 case OPEN:
20506 case OPERATOR:
20507 case ORGANIZATION:
20508 case OTHERS:
20509 case OVERRIDING:
20510 case PACKAGE:
20511 case PARTITION:
20512 case PRESERVE:
20513 case PRIVATE:
20514 case PROCEDURE:
20515 case RANGE:
20516 case RAW:
20517 case REAL:
20518 case RECORD:
20519 case REF:
20520 case RELEASE:
20521 case RELIES_ON:
20522 case RENAME:
20523 case RESULT:
20524 case RETURN:
20525 case RETURNING:
20526 case REVERSE:
20527 case ROLLBACK:
20528 case ROW:
20529 case ROWS:
20530 case ROWID:
20531 case ROWNUM:
20532 case SAVE:
20533 case SAVEPOINT:
20534 case SECOND:
20535 case SELECT:
20536 case SELF:
20537 case SET:
20538 case SPACE:
20539 case SQL:
20540 case SQLCODE:
20541 case SQLERRM:
20542 case STATIC:
20543 case SUBTYPE:
20544 case SUBSTITUTABLE:
20545 case SUCCESSFUL:
20546 case SYSDATE:
20547 case SYS_REFCURSOR:
20548 case TEMPORARY:
20549 case TIME:
20550 case TIMESTAMP:
20551 case TIMEZONE_REGION:
20552 case TIMEZONE_ABBR:
20553 case TIMEZONE_MINUTE:
20554 case TIMEZONE_HOUR:
20555 case TRANSACTION:
20556 case TRUE:
20557 case TYPE:
20558 case UNDER:
20559 case USING:
20560 case YES:
20561 case SHOW:
20562 case A:
20563 case DOUBLE:
20564 case DEC:
20565 case PRECISION:
20566 case INT:
20567 case NUMERIC:
20568 case NCHAR:
20569 case NVARCHAR2:
20570 case STRING:
20571 case UROWID:
20572 case VARRAY:
20573 case VARYING:
20574 case BFILE:
20575 case BLOB:
20576 case CLOB:
20577 case NCLOB:
20578 case YEAR:
20579 case LOCAL:
20580 case WITH:
20581 case ZONE:
20582 case CHARACTER:
20583 case AFTER:
20584 case BEFORE:
20585 case OLD:
20586 case PARENT:
20587 case CC_IF:
20588 case ANALYZE:
20589 case ASSOCIATE:
20590 case AUDIT:
20591 case COMPOUND:
20592 case DATABASE:
20593 case CALL:
20594 case DDL:
20595 case DISASSOCIATE:
20596 case EACH:
20597 case FOLLOWS:
20598 case LOGOFF:
20599 case LOGON:
20600 case NESTED:
20601 case NOAUDIT:
20602 case SCHEMA:
20603 case SERVERERROR:
20604 case SHUTDOWN:
20605 case STARTUP:
20606 case STATEMENT:
20607 case STATISTICS:
20608 case SUSPEND:
20609 case TRUNCATE:
20610 case WRAPPED:
20611 case LIBRARY:
20612 case NAME:
20613 case STRUCT:
20614 case CONTEXT:
20615 case PARAMETERS:
20616 case LENGTH:
20617 case TDO:
20618 case MAXLEN:
20619 case CHARSETID:
20620 case CHARSETFORM:
20621 case ACCEPT:
20622 case ACCESSIBLE:
20623 case COPY:
20624 case DEFINE:
20625 case DISCONNECT:
20626 case HOST:
20627 case PRINT:
20628 case QUIT:
20629 case REMARK:
20630 case UNDEFINE:
20631 case VARIABLE:
20632 case WHENEVER:
20633 case ATTACH:
20634 case CAST:
20635 case TREAT:
20636 case TRIM:
20637 case LEFT:
20638 case RIGHT:
20639 case BOTH:
20640 case EMPTY:
20641 case MULTISET:
20642 case SUBMULTISET:
20643 case LEADING:
20644 case TRAILING:
20645 case CHAR_CS:
20646 case NCHAR_CS:
20647 case AUTHENTICATED:
20648 case LINK:
20649 case SHARED:
20650 case DIRECTORY:
20651 case USER:
20652 case IDENTIFIER:
20653 case UNSIGNED_NUMERIC_LITERAL:
20654 case CHARACTER_LITERAL:
20655 case QUOTED_LITERAL:
20656 suffixNode = Expression();
20657 sb.append(" "); sb.append(suffixNode.toString());
20658 break;
20659 default:
20660 jj_la1[268] = jj_gen;
20661 jj_consume_token(-1);
20662 throw new ParseException();
20663 }
20664 break;
20665 default:
20666 jj_la1[269] = jj_gen;
20667 jj_consume_token(-1);
20668 throw new ParseException();
20669 }
20670 break;
20671 case 5:
20672 arguments = Arguments();
20673 sb.append(arguments) ;
20674 break;
20675 default:
20676 jj_la1[270] = jj_gen;
20677 jj_consume_token(-1);
20678 throw new ParseException();
20679 }
20680 jjtree.closeNodeScope(jjtn000, true);
20681 jjtc000 = false;
20682 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20683 } catch (Throwable jjte000) {
20684 if (jjtc000) {
20685 jjtree.clearNodeScope(jjtn000);
20686 jjtc000 = false;
20687 } else {
20688 jjtree.popNode();
20689 }
20690 if (jjte000 instanceof RuntimeException) {
20691 {if (true) throw (RuntimeException)jjte000;}
20692 }
20693 if (jjte000 instanceof ParseException) {
20694 {if (true) throw (ParseException)jjte000;}
20695 }
20696 {if (true) throw (Error)jjte000;}
20697 } finally {
20698 if (jjtc000) {
20699 jjtree.closeNodeScope(jjtn000, true);
20700 }
20701 }
20702 throw new Error("Missing return statement in function");
20703 }
20704
20705 final public ASTLiteral Literal() throws ParseException {
20706
20707 ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
20708 boolean jjtc000 = true;
20709 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20710 Token t = null ;
20711 try {
20712 switch (jj_nt.kind) {
20713 case UNSIGNED_NUMERIC_LITERAL:
20714 simpleNode = NumericLiteral();
20715 break;
20716 case CHARACTER_LITERAL:
20717 t = jj_consume_token(CHARACTER_LITERAL);
20718 break;
20719 case STRING_LITERAL:
20720
20721 simpleNode = StringLiteral();
20722 break;
20723 case FALSE:
20724 case TRUE:
20725 simpleNode = BooleanLiteral();
20726 break;
20727 case NULL:
20728 simpleNode = NullLiteral();
20729 break;
20730 case DATE:
20731 case INTERVAL:
20732 case TIMESTAMP:
20733 simpleNode = DateTimeLiteral();
20734 break;
20735 default:
20736 jj_la1[271] = jj_gen;
20737 jj_consume_token(-1);
20738 throw new ParseException();
20739 }
20740 jjtree.closeNodeScope(jjtn000, true);
20741 jjtc000 = false;
20742 if (null != simpleNode)
20743 {
20744 jjtn000.setImage( simpleNode.getImage() ) ;
20745 }
20746 else if (null != t)
20747 {
20748 jjtn000.setImage( t.image ) ;
20749 }
20750 {if (true) return jjtn000 ;}
20751 } catch (Throwable jjte000) {
20752 if (jjtc000) {
20753 jjtree.clearNodeScope(jjtn000);
20754 jjtc000 = false;
20755 } else {
20756 jjtree.popNode();
20757 }
20758 if (jjte000 instanceof RuntimeException) {
20759 {if (true) throw (RuntimeException)jjte000;}
20760 }
20761 if (jjte000 instanceof ParseException) {
20762 {if (true) throw (ParseException)jjte000;}
20763 }
20764 {if (true) throw (Error)jjte000;}
20765 } finally {
20766 if (jjtc000) {
20767 jjtree.closeNodeScope(jjtn000, true);
20768 }
20769 }
20770 throw new Error("Missing return statement in function");
20771 }
20772
20773 final public ASTStringLiteral StringLiteral() throws ParseException {
20774
20775 ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
20776 boolean jjtc000 = true;
20777 jjtree.openNodeScope(jjtn000);Token thisToken = null;
20778 StringBuilder literal = new StringBuilder() ;
20779 char startDelimiter ;
20780 char endDelimiter ;
20781 String terminator = null;
20782 try {
20783 thisToken = jj_consume_token(STRING_LITERAL);
20784 literal.append(thisToken.image);
20785
20786
20787
20788
20789
20790 if (thisToken.image.toUpperCase().startsWith("Q'")
20791 && thisToken.image.length() > 2
20792 )
20793 {
20794
20795
20796 startDelimiter= thisToken.image.charAt(2) ;
20797
20798
20799
20800
20801 switch (startDelimiter)
20802 {
20803 case '<' : endDelimiter = '>' ; break ;
20804 case '{' : endDelimiter = '}' ; break ;
20805 case '(' : endDelimiter = ')' ; break ;
20806 case '[' : endDelimiter = ']' ; break ;
20807 default: endDelimiter = startDelimiter ;
20808 }
20809
20810 terminator = new String(endDelimiter + "'");
20811 if (!thisToken.image.endsWith(terminator))
20812 {
20813
20814 literal.append(ReadPastNextOccurrence(terminator));
20815 }
20816 }
20817 jjtree.closeNodeScope(jjtn000, true);
20818 jjtc000 = false;
20819 jjtn000.setImage(literal.toString()) ; jjtn000.value = literal.toString() ; {if (true) return jjtn000 ;}
20820 } finally {
20821 if (jjtc000) {
20822 jjtree.closeNodeScope(jjtn000, true);
20823 }
20824 }
20825 throw new Error("Missing return statement in function");
20826 }
20827
20828 final public ASTBooleanLiteral BooleanLiteral() throws ParseException {
20829
20830 ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
20831 boolean jjtc000 = true;
20832 jjtree.openNodeScope(jjtn000);
20833 try {
20834 switch (jj_nt.kind) {
20835 case TRUE:
20836 jj_consume_token(TRUE);
20837 break;
20838 case FALSE:
20839 jj_consume_token(FALSE);
20840 break;
20841 default:
20842 jj_la1[272] = jj_gen;
20843 jj_consume_token(-1);
20844 throw new ParseException();
20845 }
20846 jjtree.closeNodeScope(jjtn000, true);
20847 jjtc000 = false;
20848 jjtn000.setImage(token.image) ;
20849 {if (true) return jjtn000;}
20850 } finally {
20851 if (jjtc000) {
20852 jjtree.closeNodeScope(jjtn000, true);
20853 }
20854 }
20855 throw new Error("Missing return statement in function");
20856 }
20857
20858 final public ASTNullLiteral NullLiteral() throws ParseException {
20859
20860 ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
20861 boolean jjtc000 = true;
20862 jjtree.openNodeScope(jjtn000);
20863 try {
20864 jj_consume_token(NULL);
20865 jjtree.closeNodeScope(jjtn000, true);
20866 jjtc000 = false;
20867 jjtn000.setImage(token.image) ;
20868 {if (true) return jjtn000 ;}
20869 } finally {
20870 if (jjtc000) {
20871 jjtree.closeNodeScope(jjtn000, true);
20872 }
20873 }
20874 throw new Error("Missing return statement in function");
20875 }
20876
20877 final public ASTMultiSetCondition MultiSetCondition() throws ParseException {
20878
20879 ASTMultiSetCondition jjtn000 = new ASTMultiSetCondition(this, JJTMULTISETCONDITION);
20880 boolean jjtc000 = true;
20881 jjtree.openNodeScope(jjtn000);
20882 try {
20883 switch (jj_nt.kind) {
20884 case A:
20885 jj_consume_token(A);
20886 jj_consume_token(SET);
20887 break;
20888 case EMPTY:
20889 jj_consume_token(EMPTY);
20890 break;
20891 default:
20892 jj_la1[273] = jj_gen;
20893 jj_consume_token(-1);
20894 throw new ParseException();
20895 }
20896 jjtree.closeNodeScope(jjtn000, true);
20897 jjtc000 = false;
20898 {if (true) return jjtn000;}
20899 } finally {
20900 if (jjtc000) {
20901 jjtree.closeNodeScope(jjtn000, true);
20902 }
20903 }
20904 throw new Error("Missing return statement in function");
20905 }
20906
20907
20908
20909
20910
20911
20912 final public ASTNumericLiteral NumericLiteral() throws ParseException {
20913
20914 ASTNumericLiteral jjtn000 = new ASTNumericLiteral(this, JJTNUMERICLITERAL);
20915 boolean jjtc000 = true;
20916 jjtree.openNodeScope(jjtn000);Token t = null ;
20917 try {
20918
20919 t = jj_consume_token(UNSIGNED_NUMERIC_LITERAL);
20920 jjtree.closeNodeScope(jjtn000, true);
20921 jjtc000 = false;
20922 jjtn000.setImage(t.image) ;
20923 {if (true) return jjtn000;}
20924 } finally {
20925 if (jjtc000) {
20926 jjtree.closeNodeScope(jjtn000, true);
20927 }
20928 }
20929 throw new Error("Missing return statement in function");
20930 }
20931
20932
20933
20934 final public ASTLabel Label() throws ParseException {
20935
20936 ASTLabel jjtn000 = new ASTLabel(this, JJTLABEL);
20937 boolean jjtc000 = true;
20938 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20939 try {
20940 jj_consume_token(21);
20941 simpleNode = UnqualifiedID();
20942 jj_consume_token(22);
20943 jjtree.closeNodeScope(jjtn000, true);
20944 jjtc000 = false;
20945 jjtn000.setImage( simpleNode.getImage() ) ;
20946 {if (true) return jjtn000;}
20947 } catch (Throwable jjte000) {
20948 if (jjtc000) {
20949 jjtree.clearNodeScope(jjtn000);
20950 jjtc000 = false;
20951 } else {
20952 jjtree.popNode();
20953 }
20954 if (jjte000 instanceof RuntimeException) {
20955 {if (true) throw (RuntimeException)jjte000;}
20956 }
20957 if (jjte000 instanceof ParseException) {
20958 {if (true) throw (ParseException)jjte000;}
20959 }
20960 {if (true) throw (Error)jjte000;}
20961 } finally {
20962 if (jjtc000) {
20963 jjtree.closeNodeScope(jjtn000, true);
20964 }
20965 }
20966 throw new Error("Missing return statement in function");
20967 }
20968
20969 final public ASTName Name() throws ParseException {
20970
20971 ASTName jjtn000 = new ASTName(this, JJTNAME);
20972 boolean jjtc000 = true;
20973 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20974 StringBuilder sb = new StringBuilder();
20975 try {
20976 simpleNode = UnqualifiedID();
20977 sb.append(simpleNode.getImage()) ;
20978 label_64:
20979 while (true) {
20980 if (jj_2_58(2)) {
20981 ;
20982 } else {
20983 break label_64;
20984 }
20985 switch (jj_nt.kind) {
20986 case 3:
20987 jj_consume_token(3);
20988 sb.append(".") ;
20989 break;
20990 case 11:
20991 jj_consume_token(11);
20992 sb.append("%") ;
20993 break;
20994 default:
20995 jj_la1[274] = jj_gen;
20996 jj_consume_token(-1);
20997 throw new ParseException();
20998 }
20999
21000 simpleNode = QualifiedID();
21001 sb.append(simpleNode.getImage()) ;
21002 }
21003 jjtree.closeNodeScope(jjtn000, true);
21004 jjtc000 = false;
21005 jjtn000.setImage(sb.toString()) ;
21006 {if (true) return jjtn000;}
21007 } catch (Throwable jjte000) {
21008 if (jjtc000) {
21009 jjtree.clearNodeScope(jjtn000);
21010 jjtc000 = false;
21011 } else {
21012 jjtree.popNode();
21013 }
21014 if (jjte000 instanceof RuntimeException) {
21015 {if (true) throw (RuntimeException)jjte000;}
21016 }
21017 if (jjte000 instanceof ParseException) {
21018 {if (true) throw (ParseException)jjte000;}
21019 }
21020 {if (true) throw (Error)jjte000;}
21021 } finally {
21022 if (jjtc000) {
21023 jjtree.closeNodeScope(jjtn000, true);
21024 }
21025 }
21026 throw new Error("Missing return statement in function");
21027 }
21028
21029 final public ASTQualifiedName QualifiedName() throws ParseException {
21030
21031 ASTQualifiedName jjtn000 = new ASTQualifiedName(this, JJTQUALIFIEDNAME);
21032 boolean jjtc000 = true;
21033 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21034 StringBuilder sb = new StringBuilder();
21035 try {
21036 simpleNode = UnqualifiedID();
21037 sb.append(simpleNode.getImage()) ;
21038 label_65:
21039 while (true) {
21040 switch (jj_nt.kind) {
21041 case 3:
21042 ;
21043 break;
21044 default:
21045 jj_la1[275] = jj_gen;
21046 break label_65;
21047 }
21048 jj_consume_token(3);
21049 simpleNode = QualifiedID();
21050 sb.append(".") ; sb.append(simpleNode.getImage()) ;
21051 }
21052 jjtree.closeNodeScope(jjtn000, true);
21053 jjtc000 = false;
21054 jjtn000.setImage(sb.toString()) ;
21055 {if (true) return jjtn000 ;}
21056 } catch (Throwable jjte000) {
21057 if (jjtc000) {
21058 jjtree.clearNodeScope(jjtn000);
21059 jjtc000 = false;
21060 } else {
21061 jjtree.popNode();
21062 }
21063 if (jjte000 instanceof RuntimeException) {
21064 {if (true) throw (RuntimeException)jjte000;}
21065 }
21066 if (jjte000 instanceof ParseException) {
21067 {if (true) throw (ParseException)jjte000;}
21068 }
21069 {if (true) throw (Error)jjte000;}
21070 } finally {
21071 if (jjtc000) {
21072 jjtree.closeNodeScope(jjtn000, true);
21073 }
21074 }
21075 throw new Error("Missing return statement in function");
21076 }
21077
21078 final public ASTArguments Arguments() throws ParseException {
21079
21080 ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
21081 boolean jjtc000 = true;
21082 jjtree.openNodeScope(jjtn000);
21083 try {
21084 jj_consume_token(5);
21085 switch (jj_nt.kind) {
21086 case 5:
21087 case 16:
21088 case 17:
21089 case REPLACE:
21090 case DEFINER:
21091 case CURRENT_USER:
21092 case LANGUAGE:
21093 case INLINE:
21094 case ADD:
21095 case AGGREGATE:
21096 case ARRAY:
21097 case AT:
21098 case ATTRIBUTE:
21099 case AUTHID:
21100 case BODY:
21101 case BULK:
21102 case BYTE:
21103 case CASCADE:
21104 case CASE:
21105 case CLOSE:
21106 case COALESCE:
21107 case COLLECT:
21108 case COLUMN:
21109 case COMMENT:
21110 case COMMIT:
21111 case CONSTRUCTOR:
21112 case CONTINUE:
21113 case CONVERT:
21114 case CURRENT:
21115 case CURSOR:
21116 case DATA:
21117 case DATE:
21118 case DAY:
21119 case DISABLE:
21120 case EDITIONABLE:
21121 case ELEMENT:
21122 case ENABLE:
21123 case ESCAPE:
21124 case EXCEPT:
21125 case EXCEPTIONS:
21126 case EXIT:
21127 case EXTERNAL:
21128 case EXTENDS:
21129 case EXTRACT:
21130 case FALSE:
21131 case FINAL:
21132 case FORCE:
21133 case FUNCTION:
21134 case GLOBAL:
21135 case HASH:
21136 case HEAP:
21137 case HOUR:
21138 case IMMEDIATE:
21139 case INDICES:
21140 case INDEXTYPE:
21141 case INDICATOR:
21142 case INSTANTIABLE:
21143 case INTERVAL:
21144 case INVALIDATE:
21145 case ISOLATION:
21146 case JAVA:
21147 case LEVEL:
21148 case LIMIT:
21149 case LOOP:
21150 case MAP:
21151 case MAX:
21152 case MEMBER:
21153 case MERGE:
21154 case MIN:
21155 case MINUTE:
21156 case MLSLABEL:
21157 case MODIFY:
21158 case MOD:
21159 case MONTH:
21160 case NATURAL:
21161 case NEW:
21162 case NEW_DOT:
21163 case NO:
21164 case NONEDITIONABLE:
21165 case NOT:
21166 case NULL:
21167 case NULLIF:
21168 case OBJECT:
21169 case OID:
21170 case OPAQUE:
21171 case OPEN:
21172 case OPERATOR:
21173 case ORGANIZATION:
21174 case OTHERS:
21175 case OVERRIDING:
21176 case PACKAGE:
21177 case PARTITION:
21178 case PRESERVE:
21179 case PRIVATE:
21180 case PROCEDURE:
21181 case RANGE:
21182 case RAW:
21183 case REAL:
21184 case RECORD:
21185 case REF:
21186 case RELEASE:
21187 case RELIES_ON:
21188 case RENAME:
21189 case RESULT:
21190 case RETURN:
21191 case RETURNING:
21192 case REVERSE:
21193 case ROLLBACK:
21194 case ROW:
21195 case ROWS:
21196 case ROWID:
21197 case ROWNUM:
21198 case SAVE:
21199 case SAVEPOINT:
21200 case SECOND:
21201 case SELECT:
21202 case SELF:
21203 case SET:
21204 case SPACE:
21205 case SQL:
21206 case SQLCODE:
21207 case SQLERRM:
21208 case STATIC:
21209 case SUBTYPE:
21210 case SUBSTITUTABLE:
21211 case SUCCESSFUL:
21212 case SYSDATE:
21213 case SYS_REFCURSOR:
21214 case TEMPORARY:
21215 case TIME:
21216 case TIMESTAMP:
21217 case TIMEZONE_REGION:
21218 case TIMEZONE_ABBR:
21219 case TIMEZONE_MINUTE:
21220 case TIMEZONE_HOUR:
21221 case TRANSACTION:
21222 case TRUE:
21223 case TYPE:
21224 case UNDER:
21225 case USING:
21226 case YES:
21227 case SHOW:
21228 case A:
21229 case DOUBLE:
21230 case DEC:
21231 case PRECISION:
21232 case INT:
21233 case NUMERIC:
21234 case NCHAR:
21235 case NVARCHAR2:
21236 case STRING:
21237 case UROWID:
21238 case VARRAY:
21239 case VARYING:
21240 case BFILE:
21241 case BLOB:
21242 case CLOB:
21243 case NCLOB:
21244 case YEAR:
21245 case LOCAL:
21246 case WITH:
21247 case ZONE:
21248 case CHARACTER:
21249 case AFTER:
21250 case BEFORE:
21251 case OLD:
21252 case PARENT:
21253 case CC_IF:
21254 case ANALYZE:
21255 case ASSOCIATE:
21256 case AUDIT:
21257 case COMPOUND:
21258 case DATABASE:
21259 case CALL:
21260 case DDL:
21261 case DISASSOCIATE:
21262 case EACH:
21263 case FOLLOWS:
21264 case LOGOFF:
21265 case LOGON:
21266 case NESTED:
21267 case NOAUDIT:
21268 case SCHEMA:
21269 case SERVERERROR:
21270 case SHUTDOWN:
21271 case STARTUP:
21272 case STATEMENT:
21273 case STATISTICS:
21274 case SUSPEND:
21275 case TRUNCATE:
21276 case WRAPPED:
21277 case LIBRARY:
21278 case NAME:
21279 case STRUCT:
21280 case CONTEXT:
21281 case PARAMETERS:
21282 case LENGTH:
21283 case TDO:
21284 case MAXLEN:
21285 case CHARSETID:
21286 case CHARSETFORM:
21287 case ACCEPT:
21288 case ACCESSIBLE:
21289 case COPY:
21290 case DEFINE:
21291 case DISCONNECT:
21292 case HOST:
21293 case PRINT:
21294 case QUIT:
21295 case REMARK:
21296 case UNDEFINE:
21297 case VARIABLE:
21298 case WHENEVER:
21299 case ATTACH:
21300 case CAST:
21301 case TREAT:
21302 case TRIM:
21303 case LEFT:
21304 case RIGHT:
21305 case BOTH:
21306 case EMPTY:
21307 case MULTISET:
21308 case SUBMULTISET:
21309 case LEADING:
21310 case TRAILING:
21311 case CHAR_CS:
21312 case NCHAR_CS:
21313 case DBTIMEZONE:
21314 case SESSIONTIMEZONE:
21315 case AUTHENTICATED:
21316 case LINK:
21317 case SHARED:
21318 case DIRECTORY:
21319 case USER:
21320 case IDENTIFIER:
21321 case UNSIGNED_NUMERIC_LITERAL:
21322 case CHARACTER_LITERAL:
21323 case STRING_LITERAL:
21324 case QUOTED_LITERAL:
21325 ArgumentList();
21326 break;
21327 default:
21328 jj_la1[276] = jj_gen;
21329 ;
21330 }
21331 jj_consume_token(7);
21332 jjtree.closeNodeScope(jjtn000, true);
21333 jjtc000 = false;
21334 {if (true) return jjtn000 ;}
21335 } catch (Throwable jjte000) {
21336 if (jjtc000) {
21337 jjtree.clearNodeScope(jjtn000);
21338 jjtc000 = false;
21339 } else {
21340 jjtree.popNode();
21341 }
21342 if (jjte000 instanceof RuntimeException) {
21343 {if (true) throw (RuntimeException)jjte000;}
21344 }
21345 if (jjte000 instanceof ParseException) {
21346 {if (true) throw (ParseException)jjte000;}
21347 }
21348 {if (true) throw (Error)jjte000;}
21349 } finally {
21350 if (jjtc000) {
21351 jjtree.closeNodeScope(jjtn000, true);
21352 }
21353 }
21354 throw new Error("Missing return statement in function");
21355 }
21356
21357 final public ASTArgumentList ArgumentList() throws ParseException {
21358
21359 ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
21360 boolean jjtc000 = true;
21361 jjtree.openNodeScope(jjtn000);
21362 try {
21363 Argument();
21364 label_66:
21365 while (true) {
21366 switch (jj_nt.kind) {
21367 case 6:
21368 ;
21369 break;
21370 default:
21371 jj_la1[277] = jj_gen;
21372 break label_66;
21373 }
21374 jj_consume_token(6);
21375 Argument();
21376 }
21377 jjtree.closeNodeScope(jjtn000, true);
21378 jjtc000 = false;
21379 {if (true) return jjtn000 ;}
21380 } catch (Throwable jjte000) {
21381 if (jjtc000) {
21382 jjtree.clearNodeScope(jjtn000);
21383 jjtc000 = false;
21384 } else {
21385 jjtree.popNode();
21386 }
21387 if (jjte000 instanceof RuntimeException) {
21388 {if (true) throw (RuntimeException)jjte000;}
21389 }
21390 if (jjte000 instanceof ParseException) {
21391 {if (true) throw (ParseException)jjte000;}
21392 }
21393 {if (true) throw (Error)jjte000;}
21394 } finally {
21395 if (jjtc000) {
21396 jjtree.closeNodeScope(jjtn000, true);
21397 }
21398 }
21399 throw new Error("Missing return statement in function");
21400 }
21401
21402 final public ASTArgument Argument() throws ParseException {
21403
21404 ASTArgument jjtn000 = new ASTArgument(this, JJTARGUMENT);
21405 boolean jjtc000 = true;
21406 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21407 try {
21408 if (jj_2_59(2)) {
21409 simpleNode = UnqualifiedID();
21410 switch (jj_nt.kind) {
21411 case 23:
21412 jj_consume_token(23);
21413 break;
21414 case AS:
21415 jj_consume_token(AS);
21416 break;
21417 default:
21418 jj_la1[278] = jj_gen;
21419 jj_consume_token(-1);
21420 throw new ParseException();
21421 }
21422 } else {
21423 ;
21424 }
21425 Expression();
21426 switch (jj_nt.kind) {
21427 case USING:
21428 jj_consume_token(USING);
21429 switch (jj_nt.kind) {
21430 case CHAR_CS:
21431 jj_consume_token(CHAR_CS);
21432 break;
21433 case NCHAR_CS:
21434 jj_consume_token(NCHAR_CS);
21435 break;
21436 default:
21437 jj_la1[279] = jj_gen;
21438 jj_consume_token(-1);
21439 throw new ParseException();
21440 }
21441 break;
21442 default:
21443 jj_la1[280] = jj_gen;
21444 ;
21445 }
21446 jjtree.closeNodeScope(jjtn000, true);
21447 jjtc000 = false;
21448 if (null != simpleNode) { jjtn000.setImage(simpleNode.getImage()) ; }
21449 {if (true) return jjtn000 ;}
21450 } catch (Throwable jjte000) {
21451 if (jjtc000) {
21452 jjtree.clearNodeScope(jjtn000);
21453 jjtc000 = false;
21454 } else {
21455 jjtree.popNode();
21456 }
21457 if (jjte000 instanceof RuntimeException) {
21458 {if (true) throw (RuntimeException)jjte000;}
21459 }
21460 if (jjte000 instanceof ParseException) {
21461 {if (true) throw (ParseException)jjte000;}
21462 }
21463 {if (true) throw (Error)jjte000;}
21464 } finally {
21465 if (jjtc000) {
21466 jjtree.closeNodeScope(jjtn000, true);
21467 }
21468 }
21469 throw new Error("Missing return statement in function");
21470 }
21471
21472
21473
21474
21475 final public ASTVariableOrConstantDeclaration VariableOrConstantDeclaration() throws ParseException {
21476
21477 ASTVariableOrConstantDeclaration jjtn000 = new ASTVariableOrConstantDeclaration(this, JJTVARIABLEORCONSTANTDECLARATION);
21478 boolean jjtc000 = true;
21479 jjtree.openNodeScope(jjtn000);
21480 try {
21481 VariableOrConstantDeclarator();
21482 jj_consume_token(4);
21483 jjtree.closeNodeScope(jjtn000, true);
21484 jjtc000 = false;
21485 {if (true) return jjtn000 ;}
21486 } catch (Throwable jjte000) {
21487 if (jjtc000) {
21488 jjtree.clearNodeScope(jjtn000);
21489 jjtc000 = false;
21490 } else {
21491 jjtree.popNode();
21492 }
21493 if (jjte000 instanceof RuntimeException) {
21494 {if (true) throw (RuntimeException)jjte000;}
21495 }
21496 if (jjte000 instanceof ParseException) {
21497 {if (true) throw (ParseException)jjte000;}
21498 }
21499 {if (true) throw (Error)jjte000;}
21500 } finally {
21501 if (jjtc000) {
21502 jjtree.closeNodeScope(jjtn000, true);
21503 }
21504 }
21505 throw new Error("Missing return statement in function");
21506 }
21507
21508 final public ASTDatatypeDeclaration DatatypeDeclaration() throws ParseException {
21509
21510 ASTDatatypeDeclaration jjtn000 = new ASTDatatypeDeclaration(this, JJTDATATYPEDECLARATION);
21511 boolean jjtc000 = true;
21512 jjtree.openNodeScope(jjtn000);Token t ;
21513 try {
21514 t = jj_consume_token(IDENTIFIER);
21515 jjtree.closeNodeScope(jjtn000, true);
21516 jjtc000 = false;
21517 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
21518 } finally {
21519 if (jjtc000) {
21520 jjtree.closeNodeScope(jjtn000, true);
21521 }
21522 }
21523 throw new Error("Missing return statement in function");
21524 }
21525
21526 final public ASTPragma Pragma() throws ParseException {
21527
21528 ASTPragma jjtn000 = new ASTPragma(this, JJTPRAGMA);
21529 boolean jjtc000 = true;
21530 jjtree.openNodeScope(jjtn000);
21531 try {
21532 jj_consume_token(PRAGMA);
21533 switch (jj_nt.kind) {
21534 case SERIALLY_REUSABLE:
21535 jj_consume_token(SERIALLY_REUSABLE);
21536 break;
21537 case AUTONOMOUS_TRANSACTION:
21538 jj_consume_token(AUTONOMOUS_TRANSACTION);
21539 break;
21540 case TIMESTAMP:
21541 jj_consume_token(TIMESTAMP);
21542 jj_consume_token(5);
21543 StringLiteral();
21544 jj_consume_token(7);
21545 break;
21546 case RESTRICT_REFERENCES:
21547 jj_consume_token(RESTRICT_REFERENCES);
21548 jj_consume_token(5);
21549 ID();
21550 label_67:
21551 while (true) {
21552 jj_consume_token(6);
21553 switch (jj_nt.kind) {
21554 case REPLACE:
21555 case DEFINER:
21556 case CURRENT_USER:
21557 case SERIALLY_REUSABLE:
21558 case RESTRICT_REFERENCES:
21559 case EXCEPTION_INIT:
21560 case AUTONOMOUS_TRANSACTION:
21561 case LANGUAGE:
21562 case INLINE:
21563 case ADD:
21564 case AGGREGATE:
21565 case ALL:
21566 case ALTER:
21567 case AND:
21568 case ANY:
21569 case ARRAY:
21570 case AS:
21571 case ASC:
21572 case AT:
21573 case ATTRIBUTE:
21574 case AUTHID:
21575 case AVG:
21576 case BETWEEN:
21577 case BINARY_INTEGER:
21578 case BODY:
21579 case BOOLEAN:
21580 case BULK:
21581 case BY:
21582 case BYTE:
21583 case CASCADE:
21584 case CASE:
21585 case CHAR:
21586 case CHAR_BASE:
21587 case CHECK:
21588 case CLOSE:
21589 case CLUSTER:
21590 case COALESCE:
21591 case COLLECT:
21592 case COLUMN:
21593 case COMMENT:
21594 case COMMIT:
21595 case COMPRESS:
21596 case CONNECT:
21597 case CONSTANT:
21598 case CONSTRUCTOR:
21599 case CONTINUE:
21600 case CONVERT:
21601 case CREATE:
21602 case CURRENT:
21603 case CURRVAL:
21604 case CURSOR:
21605 case DATA:
21606 case DATE:
21607 case DAY:
21608 case DECLARE:
21609 case DECIMAL:
21610 case _DEFAULT:
21611 case DELETE:
21612 case DESC:
21613 case DISABLE:
21614 case DISTINCT:
21615 case DO:
21616 case DROP:
21617 case EDITIONABLE:
21618 case ELEMENT:
21619 case ELSE:
21620 case ELSIF:
21621 case ENABLE:
21622 case ESCAPE:
21623 case EXCEPT:
21624 case EXCEPTION:
21625 case EXCEPTIONS:
21626 case EXCLUSIVE:
21627 case EXECUTE:
21628 case EXISTS:
21629 case EXIT:
21630 case EXTERNAL:
21631 case EXTENDS:
21632 case EXTRACT:
21633 case FALSE:
21634 case FETCH:
21635 case FINAL:
21636 case FLOAT:
21637 case FOR:
21638 case FORALL:
21639 case FORCE:
21640 case FROM:
21641 case FUNCTION:
21642 case GLOBAL:
21643 case GOTO:
21644 case GROUP:
21645 case HASH:
21646 case HAVING:
21647 case HEAP:
21648 case HOUR:
21649 case IF:
21650 case IMMEDIATE:
21651 case IN:
21652 case INDEX:
21653 case INDICES:
21654 case INDEXTYPE:
21655 case INDICATOR:
21656 case INSERT:
21657 case INSTANTIABLE:
21658 case INTEGER:
21659 case INTERFACE:
21660 case INTERSECT:
21661 case INTERVAL:
21662 case INTO:
21663 case INVALIDATE:
21664 case IS:
21665 case ISOLATION:
21666 case JAVA:
21667 case LEVEL:
21668 case LIKE:
21669 case LIMIT:
21670 case LIMITED:
21671 case LOCK:
21672 case LONG:
21673 case LOOP:
21674 case MAP:
21675 case MAX:
21676 case MEMBER:
21677 case MERGE:
21678 case MIN:
21679 case MINUS:
21680 case MINUTE:
21681 case MLSLABEL:
21682 case MODIFY:
21683 case MOD:
21684 case MODE:
21685 case MONTH:
21686 case NATURAL:
21687 case NATURALN:
21688 case NEW:
21689 case NEXTVAL:
21690 case NO:
21691 case NOCOPY:
21692 case NONEDITIONABLE:
21693 case NOT:
21694 case NOWAIT:
21695 case NULL:
21696 case NULLIF:
21697 case NUMBER:
21698 case BFILE_BASE:
21699 case BLOB_BASE:
21700 case CLOB_BASE:
21701 case DATE_BASE:
21702 case NUMBER_BASE:
21703 case OBJECT:
21704 case OCIROWID:
21705 case OF:
21706 case OID:
21707 case ON:
21708 case OPAQUE:
21709 case OPEN:
21710 case OPERATOR:
21711 case OPTION:
21712 case OR:
21713 case ORDER:
21714 case ORGANIZATION:
21715 case OTHERS:
21716 case OUT:
21717 case OVERRIDING:
21718 case PACKAGE:
21719 case PARTITION:
21720 case PCTFREE:
21721 case PLS_INTEGER:
21722 case POSITIVE:
21723 case POSITIVEN:
21724 case PRESERVE:
21725 case PRIOR:
21726 case PROMPT:
21727 case PRIVATE:
21728 case PROCEDURE:
21729 case PUBLIC:
21730 case RAISE:
21731 case RANGE:
21732 case RAW:
21733 case REAL:
21734 case RECORD:
21735 case REF:
21736 case RELEASE:
21737 case RELIES_ON:
21738 case RENAME:
21739 case RESULT:
21740 case RETURN:
21741 case RETURNING:
21742 case REVERSE:
21743 case ROLLBACK:
21744 case ROW:
21745 case ROWS:
21746 case ROWID:
21747 case ROWNUM:
21748 case ROWTYPE:
21749 case SAVE:
21750 case SAVEPOINT:
21751 case SECOND:
21752 case SELECT:
21753 case SELF:
21754 case SEPARATE:
21755 case SET:
21756 case SHARE:
21757 case SMALLINT:
21758 case SPACE:
21759 case SQL:
21760 case SQLCODE:
21761 case SQLERRM:
21762 case START:
21763 case STATIC:
21764 case STDDEV:
21765 case SUBTYPE:
21766 case SUBSTITUTABLE:
21767 case SUCCESSFUL:
21768 case SUM:
21769 case SYNONYM:
21770 case SYSDATE:
21771 case SYS_REFCURSOR:
21772 case TABLE:
21773 case TEMPORARY:
21774 case THEN:
21775 case TIME:
21776 case TIMESTAMP:
21777 case TIMEZONE_REGION:
21778 case TIMEZONE_ABBR:
21779 case TIMEZONE_MINUTE:
21780 case TIMEZONE_HOUR:
21781 case TO:
21782 case TRANSACTION:
21783 case TRIGGER:
21784 case TRUE:
21785 case TYPE:
21786 case UI:
21787 case UNDER:
21788 case USING:
21789 case WHILE:
21790 case YES:
21791 case SHOW:
21792 case A:
21793 case UPDATE:
21794 case VARCHAR:
21795 case VARCHAR2:
21796 case DOUBLE:
21797 case DEC:
21798 case PRECISION:
21799 case INT:
21800 case NUMERIC:
21801 case SIGNTYPE:
21802 case NCHAR:
21803 case NVARCHAR2:
21804 case STRING:
21805 case UROWID:
21806 case VARRAY:
21807 case VARYING:
21808 case BFILE:
21809 case BLOB:
21810 case CLOB:
21811 case NCLOB:
21812 case YEAR:
21813 case LOCAL:
21814 case WITH:
21815 case ZONE:
21816 case CHARACTER:
21817 case AFTER:
21818 case BEFORE:
21819 case OLD:
21820 case PARENT:
21821 case ANALYZE:
21822 case ASSOCIATE:
21823 case AUDIT:
21824 case COMPOUND:
21825 case DATABASE:
21826 case CALL:
21827 case DDL:
21828 case DISASSOCIATE:
21829 case EACH:
21830 case FOLLOWS:
21831 case LOGOFF:
21832 case LOGON:
21833 case NESTED:
21834 case NOAUDIT:
21835 case SCHEMA:
21836 case SERVERERROR:
21837 case SHUTDOWN:
21838 case STARTUP:
21839 case STATEMENT:
21840 case STATISTICS:
21841 case SUSPEND:
21842 case TRUNCATE:
21843 case WRAPPED:
21844 case LIBRARY:
21845 case NAME:
21846 case STRUCT:
21847 case CONTEXT:
21848 case PARAMETERS:
21849 case LENGTH:
21850 case TDO:
21851 case MAXLEN:
21852 case CHARSETID:
21853 case CHARSETFORM:
21854 case ACCEPT:
21855 case ACCESSIBLE:
21856 case COPY:
21857 case DEFINE:
21858 case DISCONNECT:
21859 case HOST:
21860 case PRINT:
21861 case QUIT:
21862 case REMARK:
21863 case UNDEFINE:
21864 case VARIABLE:
21865 case WHENEVER:
21866 case ATTACH:
21867 case CAST:
21868 case TREAT:
21869 case TRIM:
21870 case LEFT:
21871 case RIGHT:
21872 case BOTH:
21873 case EMPTY:
21874 case MULTISET:
21875 case SUBMULTISET:
21876 case LEADING:
21877 case TRAILING:
21878 case CHAR_CS:
21879 case NCHAR_CS:
21880 case DBTIMEZONE:
21881 case SESSIONTIMEZONE:
21882 case AUTHENTICATED:
21883 case LINK:
21884 case SHARED:
21885 case DIRECTORY:
21886 case USER:
21887 case IDENTIFIER:
21888 case QUOTED_LITERAL:
21889 case SQLDATA_CLASS:
21890 case CUSTOMDATUM_CLASS:
21891 case ORADATA_CLASS:
21892 case JAVA_INTERFACE_CLASS:
21893 ID();
21894 break;
21895 case STRING_LITERAL:
21896 StringLiteral();
21897 break;
21898 default:
21899 jj_la1[281] = jj_gen;
21900 jj_consume_token(-1);
21901 throw new ParseException();
21902 }
21903 switch (jj_nt.kind) {
21904 case 6:
21905 ;
21906 break;
21907 default:
21908 jj_la1[282] = jj_gen;
21909 break label_67;
21910 }
21911 }
21912 jj_consume_token(7);
21913 break;
21914 case EXCEPTION_INIT:
21915 jj_consume_token(EXCEPTION_INIT);
21916 jj_consume_token(5);
21917 jj_consume_token(IDENTIFIER);
21918 jj_consume_token(6);
21919 switch (jj_nt.kind) {
21920 case 16:
21921 case 17:
21922 switch (jj_nt.kind) {
21923 case 16:
21924 jj_consume_token(16);
21925 break;
21926 case 17:
21927 jj_consume_token(17);
21928 break;
21929 default:
21930 jj_la1[283] = jj_gen;
21931 jj_consume_token(-1);
21932 throw new ParseException();
21933 }
21934 break;
21935 default:
21936 jj_la1[284] = jj_gen;
21937 ;
21938 }
21939 NumericLiteral();
21940 jj_consume_token(7);
21941 break;
21942 case INTERFACE:
21943 jj_consume_token(INTERFACE);
21944 jj_consume_token(5);
21945 jj_consume_token(IDENTIFIER);
21946 jj_consume_token(6);
21947 ID();
21948 switch (jj_nt.kind) {
21949 case 6:
21950 jj_consume_token(6);
21951 NumericLiteral();
21952 break;
21953 default:
21954 jj_la1[285] = jj_gen;
21955 ;
21956 }
21957 jj_consume_token(7);
21958 break;
21959 case REPLACE:
21960 case DEFINER:
21961 case CURRENT_USER:
21962 case LANGUAGE:
21963 case INLINE:
21964 case ADD:
21965 case AGGREGATE:
21966 case ARRAY:
21967 case AT:
21968 case ATTRIBUTE:
21969 case AUTHID:
21970 case BODY:
21971 case BULK:
21972 case BYTE:
21973 case CASCADE:
21974 case CLOSE:
21975 case COALESCE:
21976 case COLLECT:
21977 case COLUMN:
21978 case COMMENT:
21979 case COMMIT:
21980 case CONSTRUCTOR:
21981 case CONTINUE:
21982 case CONVERT:
21983 case CURRENT:
21984 case CURSOR:
21985 case DATA:
21986 case DAY:
21987 case DISABLE:
21988 case EDITIONABLE:
21989 case ELEMENT:
21990 case ENABLE:
21991 case ESCAPE:
21992 case EXCEPT:
21993 case EXCEPTIONS:
21994 case EXIT:
21995 case EXTERNAL:
21996 case EXTENDS:
21997 case EXTRACT:
21998 case FALSE:
21999 case FINAL:
22000 case FORCE:
22001 case FUNCTION:
22002 case GLOBAL:
22003 case HASH:
22004 case HEAP:
22005 case HOUR:
22006 case IMMEDIATE:
22007 case INDICES:
22008 case INDEXTYPE:
22009 case INDICATOR:
22010 case INSTANTIABLE:
22011 case INTERVAL:
22012 case INVALIDATE:
22013 case ISOLATION:
22014 case JAVA:
22015 case LEVEL:
22016 case LIMIT:
22017 case LOOP:
22018 case MAP:
22019 case MAX:
22020 case MEMBER:
22021 case MERGE:
22022 case MIN:
22023 case MINUTE:
22024 case MLSLABEL:
22025 case MODIFY:
22026 case MOD:
22027 case MONTH:
22028 case NATURAL:
22029 case NEW:
22030 case NO:
22031 case NONEDITIONABLE:
22032 case NULLIF:
22033 case OBJECT:
22034 case OID:
22035 case OPAQUE:
22036 case OPEN:
22037 case OPERATOR:
22038 case ORGANIZATION:
22039 case OTHERS:
22040 case OVERRIDING:
22041 case PACKAGE:
22042 case PARTITION:
22043 case PRESERVE:
22044 case PRIVATE:
22045 case PROCEDURE:
22046 case RANGE:
22047 case RAW:
22048 case REAL:
22049 case RECORD:
22050 case REF:
22051 case RELEASE:
22052 case RELIES_ON:
22053 case RENAME:
22054 case RESULT:
22055 case RETURN:
22056 case RETURNING:
22057 case REVERSE:
22058 case ROLLBACK:
22059 case ROW:
22060 case ROWS:
22061 case ROWID:
22062 case ROWNUM:
22063 case SAVE:
22064 case SAVEPOINT:
22065 case SECOND:
22066 case SELF:
22067 case SET:
22068 case SPACE:
22069 case SQL:
22070 case SQLCODE:
22071 case SQLERRM:
22072 case STATIC:
22073 case SUBTYPE:
22074 case SUBSTITUTABLE:
22075 case SUCCESSFUL:
22076 case SYSDATE:
22077 case SYS_REFCURSOR:
22078 case TEMPORARY:
22079 case TIME:
22080 case TIMEZONE_REGION:
22081 case TIMEZONE_ABBR:
22082 case TIMEZONE_MINUTE:
22083 case TIMEZONE_HOUR:
22084 case TRANSACTION:
22085 case TRUE:
22086 case TYPE:
22087 case UNDER:
22088 case USING:
22089 case YES:
22090 case SHOW:
22091 case A:
22092 case DOUBLE:
22093 case DEC:
22094 case PRECISION:
22095 case INT:
22096 case NUMERIC:
22097 case NCHAR:
22098 case NVARCHAR2:
22099 case STRING:
22100 case UROWID:
22101 case VARRAY:
22102 case VARYING:
22103 case BFILE:
22104 case BLOB:
22105 case CLOB:
22106 case NCLOB:
22107 case YEAR:
22108 case LOCAL:
22109 case ZONE:
22110 case CHARACTER:
22111 case AFTER:
22112 case BEFORE:
22113 case OLD:
22114 case PARENT:
22115 case ANALYZE:
22116 case ASSOCIATE:
22117 case AUDIT:
22118 case COMPOUND:
22119 case DATABASE:
22120 case CALL:
22121 case DDL:
22122 case DISASSOCIATE:
22123 case EACH:
22124 case FOLLOWS:
22125 case LOGOFF:
22126 case LOGON:
22127 case NESTED:
22128 case NOAUDIT:
22129 case SCHEMA:
22130 case SERVERERROR:
22131 case SHUTDOWN:
22132 case STARTUP:
22133 case STATEMENT:
22134 case STATISTICS:
22135 case SUSPEND:
22136 case TRUNCATE:
22137 case WRAPPED:
22138 case LIBRARY:
22139 case NAME:
22140 case STRUCT:
22141 case CONTEXT:
22142 case PARAMETERS:
22143 case LENGTH:
22144 case TDO:
22145 case MAXLEN:
22146 case CHARSETID:
22147 case CHARSETFORM:
22148 case ACCEPT:
22149 case ACCESSIBLE:
22150 case COPY:
22151 case DEFINE:
22152 case DISCONNECT:
22153 case HOST:
22154 case PRINT:
22155 case QUIT:
22156 case REMARK:
22157 case UNDEFINE:
22158 case VARIABLE:
22159 case WHENEVER:
22160 case ATTACH:
22161 case CAST:
22162 case TREAT:
22163 case TRIM:
22164 case LEFT:
22165 case RIGHT:
22166 case BOTH:
22167 case EMPTY:
22168 case MULTISET:
22169 case SUBMULTISET:
22170 case LEADING:
22171 case TRAILING:
22172 case CHAR_CS:
22173 case NCHAR_CS:
22174 case DBTIMEZONE:
22175 case SESSIONTIMEZONE:
22176 case AUTHENTICATED:
22177 case LINK:
22178 case SHARED:
22179 case DIRECTORY:
22180 case USER:
22181 case IDENTIFIER:
22182 case QUOTED_LITERAL:
22183 QualifiedName();
22184 jj_consume_token(5);
22185 ReadPastNextOccurrence(")");
22186 break;
22187 default:
22188 jj_la1[286] = jj_gen;
22189 jj_consume_token(-1);
22190 throw new ParseException();
22191 }
22192 jj_consume_token(4);
22193 jjtree.closeNodeScope(jjtn000, true);
22194 jjtc000 = false;
22195 {if (true) return jjtn000 ;}
22196 } catch (Throwable jjte000) {
22197 if (jjtc000) {
22198 jjtree.clearNodeScope(jjtn000);
22199 jjtc000 = false;
22200 } else {
22201 jjtree.popNode();
22202 }
22203 if (jjte000 instanceof RuntimeException) {
22204 {if (true) throw (RuntimeException)jjte000;}
22205 }
22206 if (jjte000 instanceof ParseException) {
22207 {if (true) throw (ParseException)jjte000;}
22208 }
22209 {if (true) throw (Error)jjte000;}
22210 } finally {
22211 if (jjtc000) {
22212 jjtree.closeNodeScope(jjtn000, true);
22213 }
22214 }
22215 throw new Error("Missing return statement in function");
22216 }
22217
22218 final public ASTInlinePragma InlinePragma() throws ParseException {
22219
22220 ASTInlinePragma jjtn000 = new ASTInlinePragma(this, JJTINLINEPRAGMA);
22221 boolean jjtc000 = true;
22222 jjtree.openNodeScope(jjtn000);
22223 try {
22224 jj_consume_token(PRAGMA);
22225 jj_consume_token(INLINE);
22226 jj_consume_token(5);
22227 QualifiedName();
22228 jj_consume_token(6);
22229 StringLiteral();
22230 jj_consume_token(7);
22231 jjtree.closeNodeScope(jjtn000, true);
22232 jjtc000 = false;
22233 {if (true) return jjtn000 ;}
22234 } catch (Throwable jjte000) {
22235 if (jjtc000) {
22236 jjtree.clearNodeScope(jjtn000);
22237 jjtc000 = false;
22238 } else {
22239 jjtree.popNode();
22240 }
22241 if (jjte000 instanceof RuntimeException) {
22242 {if (true) throw (RuntimeException)jjte000;}
22243 }
22244 if (jjte000 instanceof ParseException) {
22245 {if (true) throw (ParseException)jjte000;}
22246 }
22247 {if (true) throw (Error)jjte000;}
22248 } finally {
22249 if (jjtc000) {
22250 jjtree.closeNodeScope(jjtn000, true);
22251 }
22252 }
22253 throw new Error("Missing return statement in function");
22254 }
22255
22256 final public ASTExceptionDeclaration ExceptionDeclaration() throws ParseException {
22257
22258 ASTExceptionDeclaration jjtn000 = new ASTExceptionDeclaration(this, JJTEXCEPTIONDECLARATION);
22259 boolean jjtc000 = true;
22260 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22261 try {
22262 simpleNode = ID();
22263 jj_consume_token(EXCEPTION);
22264 jj_consume_token(4);
22265 jjtree.closeNodeScope(jjtn000, true);
22266 jjtc000 = false;
22267 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22268 } catch (Throwable jjte000) {
22269 if (jjtc000) {
22270 jjtree.clearNodeScope(jjtn000);
22271 jjtc000 = false;
22272 } else {
22273 jjtree.popNode();
22274 }
22275 if (jjte000 instanceof RuntimeException) {
22276 {if (true) throw (RuntimeException)jjte000;}
22277 }
22278 if (jjte000 instanceof ParseException) {
22279 {if (true) throw (ParseException)jjte000;}
22280 }
22281 {if (true) throw (Error)jjte000;}
22282 } finally {
22283 if (jjtc000) {
22284 jjtree.closeNodeScope(jjtn000, true);
22285 }
22286 }
22287 throw new Error("Missing return statement in function");
22288 }
22289
22290 final public ASTParallelClause ParallelClause() throws ParseException {
22291
22292 ASTParallelClause jjtn000 = new ASTParallelClause(this, JJTPARALLELCLAUSE);
22293 boolean jjtc000 = true;
22294 jjtree.openNodeScope(jjtn000);
22295 try {
22296 jj_consume_token(5);
22297 jj_consume_token(PARTITION);
22298 ID();
22299 jj_consume_token(BY);
22300 switch (jj_nt.kind) {
22301 case ANY:
22302 jj_consume_token(ANY);
22303 break;
22304 case HASH:
22305 case RANGE:
22306 switch (jj_nt.kind) {
22307 case HASH:
22308 jj_consume_token(HASH);
22309 break;
22310 case RANGE:
22311 jj_consume_token(RANGE);
22312 break;
22313 default:
22314 jj_la1[287] = jj_gen;
22315 jj_consume_token(-1);
22316 throw new ParseException();
22317 }
22318 jj_consume_token(5);
22319 ID();
22320 label_68:
22321 while (true) {
22322 switch (jj_nt.kind) {
22323 case 6:
22324 ;
22325 break;
22326 default:
22327 jj_la1[288] = jj_gen;
22328 break label_68;
22329 }
22330 jj_consume_token(6);
22331 ID();
22332 }
22333 jj_consume_token(7);
22334 break;
22335 default:
22336 jj_la1[289] = jj_gen;
22337 jj_consume_token(-1);
22338 throw new ParseException();
22339 }
22340 jj_consume_token(7);
22341 switch (jj_nt.kind) {
22342 case CLUSTER:
22343 case ORDER:
22344 switch (jj_nt.kind) {
22345 case ORDER:
22346 jj_consume_token(ORDER);
22347 break;
22348 case CLUSTER:
22349 jj_consume_token(CLUSTER);
22350 break;
22351 default:
22352 jj_la1[290] = jj_gen;
22353 jj_consume_token(-1);
22354 throw new ParseException();
22355 }
22356 jj_consume_token(BY);
22357 jj_consume_token(5);
22358 ID();
22359 label_69:
22360 while (true) {
22361 switch (jj_nt.kind) {
22362 case 6:
22363 ;
22364 break;
22365 default:
22366 jj_la1[291] = jj_gen;
22367 break label_69;
22368 }
22369 jj_consume_token(6);
22370 ID();
22371 }
22372 jj_consume_token(7);
22373 break;
22374 default:
22375 jj_la1[292] = jj_gen;
22376 ;
22377 }
22378 jjtree.closeNodeScope(jjtn000, true);
22379 jjtc000 = false;
22380 {if (true) return jjtn000 ;}
22381 } catch (Throwable jjte000) {
22382 if (jjtc000) {
22383 jjtree.clearNodeScope(jjtn000);
22384 jjtc000 = false;
22385 } else {
22386 jjtree.popNode();
22387 }
22388 if (jjte000 instanceof RuntimeException) {
22389 {if (true) throw (RuntimeException)jjte000;}
22390 }
22391 if (jjte000 instanceof ParseException) {
22392 {if (true) throw (ParseException)jjte000;}
22393 }
22394 {if (true) throw (Error)jjte000;}
22395 } finally {
22396 if (jjtc000) {
22397 jjtree.closeNodeScope(jjtn000, true);
22398 }
22399 }
22400 throw new Error("Missing return statement in function");
22401 }
22402
22403 final public ASTAccessibleByClause AccessibleByClause() throws ParseException {
22404
22405 ASTAccessibleByClause jjtn000 = new ASTAccessibleByClause(this, JJTACCESSIBLEBYCLAUSE);
22406 boolean jjtc000 = true;
22407 jjtree.openNodeScope(jjtn000);
22408 try {
22409 jj_consume_token(ACCESSIBLE);
22410 jj_consume_token(BY);
22411 jj_consume_token(5);
22412 switch (jj_nt.kind) {
22413 case FUNCTION:
22414 case PACKAGE:
22415 case PROCEDURE:
22416 case TRIGGER:
22417 case TYPE:
22418 switch (jj_nt.kind) {
22419 case FUNCTION:
22420 jj_consume_token(FUNCTION);
22421 break;
22422 case PROCEDURE:
22423 jj_consume_token(PROCEDURE);
22424 break;
22425 case PACKAGE:
22426 jj_consume_token(PACKAGE);
22427 break;
22428 case TRIGGER:
22429 jj_consume_token(TRIGGER);
22430 break;
22431 case TYPE:
22432 jj_consume_token(TYPE);
22433 break;
22434 default:
22435 jj_la1[293] = jj_gen;
22436 jj_consume_token(-1);
22437 throw new ParseException();
22438 }
22439 break;
22440 default:
22441 jj_la1[294] = jj_gen;
22442 ;
22443 }
22444 QualifiedName();
22445 label_70:
22446 while (true) {
22447 switch (jj_nt.kind) {
22448 case 6:
22449 ;
22450 break;
22451 default:
22452 jj_la1[295] = jj_gen;
22453 break label_70;
22454 }
22455 jj_consume_token(6);
22456 switch (jj_nt.kind) {
22457 case FUNCTION:
22458 case PACKAGE:
22459 case PROCEDURE:
22460 case TRIGGER:
22461 case TYPE:
22462 switch (jj_nt.kind) {
22463 case FUNCTION:
22464 jj_consume_token(FUNCTION);
22465 break;
22466 case PROCEDURE:
22467 jj_consume_token(PROCEDURE);
22468 break;
22469 case PACKAGE:
22470 jj_consume_token(PACKAGE);
22471 break;
22472 case TRIGGER:
22473 jj_consume_token(TRIGGER);
22474 break;
22475 case TYPE:
22476 jj_consume_token(TYPE);
22477 break;
22478 default:
22479 jj_la1[296] = jj_gen;
22480 jj_consume_token(-1);
22481 throw new ParseException();
22482 }
22483 break;
22484 default:
22485 jj_la1[297] = jj_gen;
22486 ;
22487 }
22488 QualifiedName();
22489 }
22490 jj_consume_token(7);
22491 jjtree.closeNodeScope(jjtn000, true);
22492 jjtc000 = false;
22493 {if (true) return jjtn000 ;}
22494 } catch (Throwable jjte000) {
22495 if (jjtc000) {
22496 jjtree.clearNodeScope(jjtn000);
22497 jjtc000 = false;
22498 } else {
22499 jjtree.popNode();
22500 }
22501 if (jjte000 instanceof RuntimeException) {
22502 {if (true) throw (RuntimeException)jjte000;}
22503 }
22504 if (jjte000 instanceof ParseException) {
22505 {if (true) throw (ParseException)jjte000;}
22506 }
22507 {if (true) throw (Error)jjte000;}
22508 } finally {
22509 if (jjtc000) {
22510 jjtree.closeNodeScope(jjtn000, true);
22511 }
22512 }
22513 throw new Error("Missing return statement in function");
22514 }
22515
22516
22517
22518
22519
22520
22521
22522
22523 final public ASTTable Table() throws ParseException {
22524
22525 ASTTable jjtn000 = new ASTTable(this, JJTTABLE);
22526 boolean jjtc000 = true;
22527 jjtree.openNodeScope(jjtn000);
22528 try {
22529 jj_consume_token(CREATE);
22530 switch (jj_nt.kind) {
22531 case GLOBAL:
22532 jj_consume_token(GLOBAL);
22533 jj_consume_token(TEMPORARY);
22534 break;
22535 default:
22536 jj_la1[298] = jj_gen;
22537 ;
22538 }
22539 jj_consume_token(TABLE);
22540 ObjectNameDeclaration();
22541 jj_consume_token(5);
22542 TableColumn();
22543 label_71:
22544 while (true) {
22545 switch (jj_nt.kind) {
22546 case 6:
22547 ;
22548 break;
22549 default:
22550 jj_la1[299] = jj_gen;
22551 break label_71;
22552 }
22553 jj_consume_token(6);
22554 TableColumn();
22555 }
22556 jj_consume_token(7);
22557 if (jj_2_60(2)) {
22558 jj_consume_token(ON);
22559 jj_consume_token(COMMIT);
22560 switch (jj_nt.kind) {
22561 case DELETE:
22562 jj_consume_token(DELETE);
22563 break;
22564 case PRESERVE:
22565 jj_consume_token(PRESERVE);
22566 break;
22567 default:
22568 jj_la1[300] = jj_gen;
22569 jj_consume_token(-1);
22570 throw new ParseException();
22571 }
22572 jj_consume_token(ROWS);
22573 } else {
22574 ;
22575 }
22576 switch (jj_nt.kind) {
22577 case 4:
22578 jj_consume_token(4);
22579 break;
22580 default:
22581 jj_la1[301] = jj_gen;
22582 ;
22583 }
22584 jjtree.closeNodeScope(jjtn000, true);
22585 jjtc000 = false;
22586 {if (true) return jjtn000 ;}
22587 } catch (Throwable jjte000) {
22588 if (jjtc000) {
22589 jjtree.clearNodeScope(jjtn000);
22590 jjtc000 = false;
22591 } else {
22592 jjtree.popNode();
22593 }
22594 if (jjte000 instanceof RuntimeException) {
22595 {if (true) throw (RuntimeException)jjte000;}
22596 }
22597 if (jjte000 instanceof ParseException) {
22598 {if (true) throw (ParseException)jjte000;}
22599 }
22600 {if (true) throw (Error)jjte000;}
22601 } finally {
22602 if (jjtc000) {
22603 jjtree.closeNodeScope(jjtn000, true);
22604 }
22605 }
22606 throw new Error("Missing return statement in function");
22607 }
22608
22609 final public ASTTableColumn TableColumn() throws ParseException {
22610
22611 ASTTableColumn jjtn000 = new ASTTableColumn(this, JJTTABLECOLUMN);
22612 boolean jjtc000 = true;
22613 jjtree.openNodeScope(jjtn000);
22614 try {
22615 ID();
22616 Datatype();
22617 switch (jj_nt.kind) {
22618 case _DEFAULT:
22619 jj_consume_token(_DEFAULT);
22620 Expression();
22621 break;
22622 default:
22623 jj_la1[302] = jj_gen;
22624 ;
22625 }
22626 switch (jj_nt.kind) {
22627 case NOT:
22628 case NULL:
22629 switch (jj_nt.kind) {
22630 case NOT:
22631 jj_consume_token(NOT);
22632 break;
22633 default:
22634 jj_la1[303] = jj_gen;
22635 ;
22636 }
22637 jj_consume_token(NULL);
22638 break;
22639 default:
22640 jj_la1[304] = jj_gen;
22641 ;
22642 }
22643 jjtree.closeNodeScope(jjtn000, true);
22644 jjtc000 = false;
22645 {if (true) return jjtn000 ;}
22646 } catch (Throwable jjte000) {
22647 if (jjtc000) {
22648 jjtree.clearNodeScope(jjtn000);
22649 jjtc000 = false;
22650 } else {
22651 jjtree.popNode();
22652 }
22653 if (jjte000 instanceof RuntimeException) {
22654 {if (true) throw (RuntimeException)jjte000;}
22655 }
22656 if (jjte000 instanceof ParseException) {
22657 {if (true) throw (ParseException)jjte000;}
22658 }
22659 {if (true) throw (Error)jjte000;}
22660 } finally {
22661 if (jjtc000) {
22662 jjtree.closeNodeScope(jjtn000, true);
22663 }
22664 }
22665 throw new Error("Missing return statement in function");
22666 }
22667
22668 final public ASTView View() throws ParseException {
22669
22670 ASTView jjtn000 = new ASTView(this, JJTVIEW);
22671 boolean jjtc000 = true;
22672 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22673 try {
22674 jj_consume_token(CREATE);
22675 switch (jj_nt.kind) {
22676 case OR:
22677 jj_consume_token(OR);
22678 jj_consume_token(REPLACE);
22679 break;
22680 default:
22681 jj_la1[305] = jj_gen;
22682 ;
22683 }
22684 switch (jj_nt.kind) {
22685 case FORCE:
22686 case NO:
22687 switch (jj_nt.kind) {
22688 case NO:
22689 jj_consume_token(NO);
22690 break;
22691 default:
22692 jj_la1[306] = jj_gen;
22693 ;
22694 }
22695 jj_consume_token(FORCE);
22696 break;
22697 default:
22698 jj_la1[307] = jj_gen;
22699 ;
22700 }
22701 jj_consume_token(VIEW);
22702 simpleNode = ObjectNameDeclaration();
22703 switch (jj_nt.kind) {
22704 case 5:
22705 jj_consume_token(5);
22706 ViewColumn();
22707 label_72:
22708 while (true) {
22709 switch (jj_nt.kind) {
22710 case 6:
22711 ;
22712 break;
22713 default:
22714 jj_la1[308] = jj_gen;
22715 break label_72;
22716 }
22717 jj_consume_token(6);
22718 ViewColumn();
22719 }
22720 jj_consume_token(7);
22721 break;
22722 default:
22723 jj_la1[309] = jj_gen;
22724 ;
22725 }
22726 jj_consume_token(AS);
22727 Statement();
22728 switch (jj_nt.kind) {
22729 case 4:
22730 jj_consume_token(4);
22731 break;
22732 case 1:
22733 jj_consume_token(1);
22734 break;
22735 default:
22736 jj_la1[310] = jj_gen;
22737 jj_consume_token(-1);
22738 throw new ParseException();
22739 }
22740 jjtree.closeNodeScope(jjtn000, true);
22741 jjtc000 = false;
22742 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22743 } catch (Throwable jjte000) {
22744 if (jjtc000) {
22745 jjtree.clearNodeScope(jjtn000);
22746 jjtc000 = false;
22747 } else {
22748 jjtree.popNode();
22749 }
22750 if (jjte000 instanceof RuntimeException) {
22751 {if (true) throw (RuntimeException)jjte000;}
22752 }
22753 if (jjte000 instanceof ParseException) {
22754 {if (true) throw (ParseException)jjte000;}
22755 }
22756 {if (true) throw (Error)jjte000;}
22757 } finally {
22758 if (jjtc000) {
22759 jjtree.closeNodeScope(jjtn000, true);
22760 }
22761 }
22762 throw new Error("Missing return statement in function");
22763 }
22764
22765 final public ASTSynonym Synonym() throws ParseException {
22766
22767 ASTSynonym jjtn000 = new ASTSynonym(this, JJTSYNONYM);
22768 boolean jjtc000 = true;
22769 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22770 try {
22771 jj_consume_token(CREATE);
22772 switch (jj_nt.kind) {
22773 case OR:
22774 jj_consume_token(OR);
22775 jj_consume_token(REPLACE);
22776 break;
22777 default:
22778 jj_la1[311] = jj_gen;
22779 ;
22780 }
22781 switch (jj_nt.kind) {
22782 case PUBLIC:
22783 jj_consume_token(PUBLIC);
22784 break;
22785 default:
22786 jj_la1[312] = jj_gen;
22787 ;
22788 }
22789 jj_consume_token(SYNONYM);
22790 simpleNode = ObjectNameDeclaration();
22791 jj_consume_token(FOR);
22792 ObjectNameDeclaration();
22793 switch (jj_nt.kind) {
22794 case 4:
22795 jj_consume_token(4);
22796 break;
22797 case 1:
22798 jj_consume_token(1);
22799 break;
22800 default:
22801 jj_la1[313] = jj_gen;
22802 jj_consume_token(-1);
22803 throw new ParseException();
22804 }
22805 jjtree.closeNodeScope(jjtn000, true);
22806 jjtc000 = false;
22807 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22808 } catch (Throwable jjte000) {
22809 if (jjtc000) {
22810 jjtree.clearNodeScope(jjtn000);
22811 jjtc000 = false;
22812 } else {
22813 jjtree.popNode();
22814 }
22815 if (jjte000 instanceof RuntimeException) {
22816 {if (true) throw (RuntimeException)jjte000;}
22817 }
22818 if (jjte000 instanceof ParseException) {
22819 {if (true) throw (ParseException)jjte000;}
22820 }
22821 {if (true) throw (Error)jjte000;}
22822 } finally {
22823 if (jjtc000) {
22824 jjtree.closeNodeScope(jjtn000, true);
22825 }
22826 }
22827 throw new Error("Missing return statement in function");
22828 }
22829
22830 final public ASTDirectory Directory() throws ParseException {
22831
22832 ASTDirectory jjtn000 = new ASTDirectory(this, JJTDIRECTORY);
22833 boolean jjtc000 = true;
22834 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22835 try {
22836 jj_consume_token(CREATE);
22837 switch (jj_nt.kind) {
22838 case OR:
22839 jj_consume_token(OR);
22840 jj_consume_token(REPLACE);
22841 break;
22842 default:
22843 jj_la1[314] = jj_gen;
22844 ;
22845 }
22846 jj_consume_token(DIRECTORY);
22847 simpleNode = ObjectNameDeclaration();
22848 jj_consume_token(AS);
22849 StringLiteral();
22850 switch (jj_nt.kind) {
22851 case 4:
22852 jj_consume_token(4);
22853 break;
22854 case 1:
22855 jj_consume_token(1);
22856 break;
22857 default:
22858 jj_la1[315] = jj_gen;
22859 jj_consume_token(-1);
22860 throw new ParseException();
22861 }
22862 jjtree.closeNodeScope(jjtn000, true);
22863 jjtc000 = false;
22864 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22865 } catch (Throwable jjte000) {
22866 if (jjtc000) {
22867 jjtree.clearNodeScope(jjtn000);
22868 jjtc000 = false;
22869 } else {
22870 jjtree.popNode();
22871 }
22872 if (jjte000 instanceof RuntimeException) {
22873 {if (true) throw (RuntimeException)jjte000;}
22874 }
22875 if (jjte000 instanceof ParseException) {
22876 {if (true) throw (ParseException)jjte000;}
22877 }
22878 {if (true) throw (Error)jjte000;}
22879 } finally {
22880 if (jjtc000) {
22881 jjtree.closeNodeScope(jjtn000, true);
22882 }
22883 }
22884 throw new Error("Missing return statement in function");
22885 }
22886
22887 final public ASTDatabaseLink DatabaseLink() throws ParseException {
22888
22889 ASTDatabaseLink jjtn000 = new ASTDatabaseLink(this, JJTDATABASELINK);
22890 boolean jjtc000 = true;
22891 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22892 try {
22893 jj_consume_token(CREATE);
22894 switch (jj_nt.kind) {
22895 case SHARED:
22896 jj_consume_token(SHARED);
22897 break;
22898 default:
22899 jj_la1[316] = jj_gen;
22900 ;
22901 }
22902 switch (jj_nt.kind) {
22903 case PUBLIC:
22904 jj_consume_token(PUBLIC);
22905 break;
22906 default:
22907 jj_la1[317] = jj_gen;
22908 ;
22909 }
22910 jj_consume_token(DATABASE);
22911 jj_consume_token(LINK);
22912 simpleNode = ObjectNameDeclaration();
22913 switch (jj_nt.kind) {
22914 case CONNECT:
22915 jj_consume_token(CONNECT);
22916 jj_consume_token(TO);
22917 switch (jj_nt.kind) {
22918 case CURRENT_USER:
22919 jj_consume_token(CURRENT_USER);
22920 break;
22921 case REPLACE:
22922 case DEFINER:
22923 case LANGUAGE:
22924 case INLINE:
22925 case ADD:
22926 case AGGREGATE:
22927 case ARRAY:
22928 case AT:
22929 case ATTRIBUTE:
22930 case AUTHID:
22931 case BODY:
22932 case BULK:
22933 case BYTE:
22934 case CASCADE:
22935 case CLOSE:
22936 case COALESCE:
22937 case COLLECT:
22938 case COLUMN:
22939 case COMMENT:
22940 case COMMIT:
22941 case CONSTRUCTOR:
22942 case CONTINUE:
22943 case CONVERT:
22944 case CURRENT:
22945 case CURSOR:
22946 case DATA:
22947 case DAY:
22948 case DISABLE:
22949 case EDITIONABLE:
22950 case ELEMENT:
22951 case ENABLE:
22952 case ESCAPE:
22953 case EXCEPT:
22954 case EXCEPTIONS:
22955 case EXIT:
22956 case EXTERNAL:
22957 case EXTENDS:
22958 case EXTRACT:
22959 case FALSE:
22960 case FINAL:
22961 case FORCE:
22962 case FUNCTION:
22963 case GLOBAL:
22964 case HASH:
22965 case HEAP:
22966 case HOUR:
22967 case IMMEDIATE:
22968 case INDICES:
22969 case INDEXTYPE:
22970 case INDICATOR:
22971 case INSTANTIABLE:
22972 case INTERVAL:
22973 case INVALIDATE:
22974 case ISOLATION:
22975 case JAVA:
22976 case LEVEL:
22977 case LIMIT:
22978 case LOOP:
22979 case MAP:
22980 case MAX:
22981 case MEMBER:
22982 case MERGE:
22983 case MIN:
22984 case MINUTE:
22985 case MLSLABEL:
22986 case MODIFY:
22987 case MOD:
22988 case MONTH:
22989 case NATURAL:
22990 case NEW:
22991 case NO:
22992 case NONEDITIONABLE:
22993 case NULLIF:
22994 case OBJECT:
22995 case OID:
22996 case OPAQUE:
22997 case OPEN:
22998 case OPERATOR:
22999 case ORGANIZATION:
23000 case OTHERS:
23001 case OVERRIDING:
23002 case PACKAGE:
23003 case PARTITION:
23004 case PRESERVE:
23005 case PRIVATE:
23006 case PROCEDURE:
23007 case RANGE:
23008 case RAW:
23009 case REAL:
23010 case RECORD:
23011 case REF:
23012 case RELEASE:
23013 case RELIES_ON:
23014 case RENAME:
23015 case RESULT:
23016 case RETURN:
23017 case RETURNING:
23018 case REVERSE:
23019 case ROLLBACK:
23020 case ROW:
23021 case ROWS:
23022 case ROWID:
23023 case ROWNUM:
23024 case SAVE:
23025 case SAVEPOINT:
23026 case SECOND:
23027 case SELF:
23028 case SET:
23029 case SPACE:
23030 case SQL:
23031 case SQLCODE:
23032 case SQLERRM:
23033 case STATIC:
23034 case SUBTYPE:
23035 case SUBSTITUTABLE:
23036 case SUCCESSFUL:
23037 case SYSDATE:
23038 case SYS_REFCURSOR:
23039 case TEMPORARY:
23040 case TIME:
23041 case TIMESTAMP:
23042 case TIMEZONE_REGION:
23043 case TIMEZONE_ABBR:
23044 case TIMEZONE_MINUTE:
23045 case TIMEZONE_HOUR:
23046 case TRANSACTION:
23047 case TRUE:
23048 case TYPE:
23049 case UNDER:
23050 case USING:
23051 case YES:
23052 case SHOW:
23053 case A:
23054 case DOUBLE:
23055 case DEC:
23056 case PRECISION:
23057 case INT:
23058 case NUMERIC:
23059 case NCHAR:
23060 case NVARCHAR2:
23061 case STRING:
23062 case UROWID:
23063 case VARRAY:
23064 case VARYING:
23065 case BFILE:
23066 case BLOB:
23067 case CLOB:
23068 case NCLOB:
23069 case YEAR:
23070 case LOCAL:
23071 case ZONE:
23072 case CHARACTER:
23073 case AFTER:
23074 case BEFORE:
23075 case OLD:
23076 case PARENT:
23077 case ANALYZE:
23078 case ASSOCIATE:
23079 case AUDIT:
23080 case COMPOUND:
23081 case DATABASE:
23082 case CALL:
23083 case DDL:
23084 case DISASSOCIATE:
23085 case EACH:
23086 case FOLLOWS:
23087 case LOGOFF:
23088 case LOGON:
23089 case NESTED:
23090 case NOAUDIT:
23091 case SCHEMA:
23092 case SERVERERROR:
23093 case SHUTDOWN:
23094 case STARTUP:
23095 case STATEMENT:
23096 case STATISTICS:
23097 case SUSPEND:
23098 case TRUNCATE:
23099 case WRAPPED:
23100 case LIBRARY:
23101 case NAME:
23102 case STRUCT:
23103 case CONTEXT:
23104 case PARAMETERS:
23105 case LENGTH:
23106 case TDO:
23107 case MAXLEN:
23108 case CHARSETID:
23109 case CHARSETFORM:
23110 case ACCEPT:
23111 case ACCESSIBLE:
23112 case COPY:
23113 case DEFINE:
23114 case DISCONNECT:
23115 case HOST:
23116 case PRINT:
23117 case QUIT:
23118 case REMARK:
23119 case UNDEFINE:
23120 case VARIABLE:
23121 case WHENEVER:
23122 case ATTACH:
23123 case CAST:
23124 case TREAT:
23125 case TRIM:
23126 case LEFT:
23127 case RIGHT:
23128 case BOTH:
23129 case EMPTY:
23130 case MULTISET:
23131 case SUBMULTISET:
23132 case LEADING:
23133 case TRAILING:
23134 case CHAR_CS:
23135 case NCHAR_CS:
23136 case DBTIMEZONE:
23137 case SESSIONTIMEZONE:
23138 case AUTHENTICATED:
23139 case LINK:
23140 case SHARED:
23141 case DIRECTORY:
23142 case USER:
23143 case IDENTIFIER:
23144 case QUOTED_LITERAL:
23145 UnqualifiedID();
23146 jj_consume_token(IDENTIFIED);
23147 jj_consume_token(BY);
23148 UnqualifiedID();
23149 jj_consume_token(AUTHENTICATED);
23150 jj_consume_token(BY);
23151 UnqualifiedID();
23152 jj_consume_token(IDENTIFIED);
23153 jj_consume_token(BY);
23154 UnqualifiedID();
23155 break;
23156 default:
23157 jj_la1[318] = jj_gen;
23158 jj_consume_token(-1);
23159 throw new ParseException();
23160 }
23161 break;
23162 case REPLACE:
23163 case DEFINER:
23164 case CURRENT_USER:
23165 case LANGUAGE:
23166 case INLINE:
23167 case ADD:
23168 case AGGREGATE:
23169 case ARRAY:
23170 case AT:
23171 case ATTRIBUTE:
23172 case AUTHID:
23173 case BODY:
23174 case BULK:
23175 case BYTE:
23176 case CASCADE:
23177 case CLOSE:
23178 case COALESCE:
23179 case COLLECT:
23180 case COLUMN:
23181 case COMMENT:
23182 case COMMIT:
23183 case CONSTRUCTOR:
23184 case CONTINUE:
23185 case CONVERT:
23186 case CURRENT:
23187 case CURSOR:
23188 case DATA:
23189 case DAY:
23190 case DISABLE:
23191 case EDITIONABLE:
23192 case ELEMENT:
23193 case ENABLE:
23194 case ESCAPE:
23195 case EXCEPT:
23196 case EXCEPTIONS:
23197 case EXIT:
23198 case EXTERNAL:
23199 case EXTENDS:
23200 case EXTRACT:
23201 case FALSE:
23202 case FINAL:
23203 case FORCE:
23204 case FUNCTION:
23205 case GLOBAL:
23206 case HASH:
23207 case HEAP:
23208 case HOUR:
23209 case IMMEDIATE:
23210 case INDICES:
23211 case INDEXTYPE:
23212 case INDICATOR:
23213 case INSTANTIABLE:
23214 case INTERVAL:
23215 case INVALIDATE:
23216 case ISOLATION:
23217 case JAVA:
23218 case LEVEL:
23219 case LIMIT:
23220 case LOOP:
23221 case MAP:
23222 case MAX:
23223 case MEMBER:
23224 case MERGE:
23225 case MIN:
23226 case MINUTE:
23227 case MLSLABEL:
23228 case MODIFY:
23229 case MOD:
23230 case MONTH:
23231 case NATURAL:
23232 case NEW:
23233 case NO:
23234 case NONEDITIONABLE:
23235 case NULLIF:
23236 case OBJECT:
23237 case OID:
23238 case OPAQUE:
23239 case OPEN:
23240 case OPERATOR:
23241 case ORGANIZATION:
23242 case OTHERS:
23243 case OVERRIDING:
23244 case PACKAGE:
23245 case PARTITION:
23246 case PRESERVE:
23247 case PRIVATE:
23248 case PROCEDURE:
23249 case RANGE:
23250 case RAW:
23251 case REAL:
23252 case RECORD:
23253 case REF:
23254 case RELEASE:
23255 case RELIES_ON:
23256 case RENAME:
23257 case RESULT:
23258 case RETURN:
23259 case RETURNING:
23260 case REVERSE:
23261 case ROLLBACK:
23262 case ROW:
23263 case ROWS:
23264 case ROWID:
23265 case ROWNUM:
23266 case SAVE:
23267 case SAVEPOINT:
23268 case SECOND:
23269 case SELF:
23270 case SET:
23271 case SPACE:
23272 case SQL:
23273 case SQLCODE:
23274 case SQLERRM:
23275 case STATIC:
23276 case SUBTYPE:
23277 case SUBSTITUTABLE:
23278 case SUCCESSFUL:
23279 case SYSDATE:
23280 case SYS_REFCURSOR:
23281 case TEMPORARY:
23282 case TIME:
23283 case TIMESTAMP:
23284 case TIMEZONE_REGION:
23285 case TIMEZONE_ABBR:
23286 case TIMEZONE_MINUTE:
23287 case TIMEZONE_HOUR:
23288 case TRANSACTION:
23289 case TRUE:
23290 case TYPE:
23291 case UNDER:
23292 case USING:
23293 case YES:
23294 case SHOW:
23295 case A:
23296 case DOUBLE:
23297 case DEC:
23298 case PRECISION:
23299 case INT:
23300 case NUMERIC:
23301 case NCHAR:
23302 case NVARCHAR2:
23303 case STRING:
23304 case UROWID:
23305 case VARRAY:
23306 case VARYING:
23307 case BFILE:
23308 case BLOB:
23309 case CLOB:
23310 case NCLOB:
23311 case YEAR:
23312 case LOCAL:
23313 case ZONE:
23314 case CHARACTER:
23315 case AFTER:
23316 case BEFORE:
23317 case OLD:
23318 case PARENT:
23319 case ANALYZE:
23320 case ASSOCIATE:
23321 case AUDIT:
23322 case COMPOUND:
23323 case DATABASE:
23324 case CALL:
23325 case DDL:
23326 case DISASSOCIATE:
23327 case EACH:
23328 case FOLLOWS:
23329 case LOGOFF:
23330 case LOGON:
23331 case NESTED:
23332 case NOAUDIT:
23333 case SCHEMA:
23334 case SERVERERROR:
23335 case SHUTDOWN:
23336 case STARTUP:
23337 case STATEMENT:
23338 case STATISTICS:
23339 case SUSPEND:
23340 case TRUNCATE:
23341 case WRAPPED:
23342 case LIBRARY:
23343 case NAME:
23344 case STRUCT:
23345 case CONTEXT:
23346 case PARAMETERS:
23347 case LENGTH:
23348 case TDO:
23349 case MAXLEN:
23350 case CHARSETID:
23351 case CHARSETFORM:
23352 case ACCEPT:
23353 case ACCESSIBLE:
23354 case COPY:
23355 case DEFINE:
23356 case DISCONNECT:
23357 case HOST:
23358 case PRINT:
23359 case QUIT:
23360 case REMARK:
23361 case UNDEFINE:
23362 case VARIABLE:
23363 case WHENEVER:
23364 case ATTACH:
23365 case CAST:
23366 case TREAT:
23367 case TRIM:
23368 case LEFT:
23369 case RIGHT:
23370 case BOTH:
23371 case EMPTY:
23372 case MULTISET:
23373 case SUBMULTISET:
23374 case LEADING:
23375 case TRAILING:
23376 case CHAR_CS:
23377 case NCHAR_CS:
23378 case DBTIMEZONE:
23379 case SESSIONTIMEZONE:
23380 case AUTHENTICATED:
23381 case LINK:
23382 case SHARED:
23383 case DIRECTORY:
23384 case USER:
23385 case IDENTIFIER:
23386 case QUOTED_LITERAL:
23387 UnqualifiedID();
23388 jj_consume_token(IDENTIFIED);
23389 jj_consume_token(BY);
23390 UnqualifiedID();
23391 break;
23392 default:
23393 jj_la1[319] = jj_gen;
23394 jj_consume_token(-1);
23395 throw new ParseException();
23396 }
23397 switch (jj_nt.kind) {
23398 case USING:
23399 jj_consume_token(USING);
23400 StringLiteral();
23401 break;
23402 default:
23403 jj_la1[320] = jj_gen;
23404 ;
23405 }
23406 switch (jj_nt.kind) {
23407 case 4:
23408 jj_consume_token(4);
23409 break;
23410 case 1:
23411 jj_consume_token(1);
23412 break;
23413 default:
23414 jj_la1[321] = jj_gen;
23415 jj_consume_token(-1);
23416 throw new ParseException();
23417 }
23418 jjtree.closeNodeScope(jjtn000, true);
23419 jjtc000 = false;
23420 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
23421 } catch (Throwable jjte000) {
23422 if (jjtc000) {
23423 jjtree.clearNodeScope(jjtn000);
23424 jjtc000 = false;
23425 } else {
23426 jjtree.popNode();
23427 }
23428 if (jjte000 instanceof RuntimeException) {
23429 {if (true) throw (RuntimeException)jjte000;}
23430 }
23431 if (jjte000 instanceof ParseException) {
23432 {if (true) throw (ParseException)jjte000;}
23433 }
23434 {if (true) throw (Error)jjte000;}
23435 } finally {
23436 if (jjtc000) {
23437 jjtree.closeNodeScope(jjtn000, true);
23438 }
23439 }
23440 throw new Error("Missing return statement in function");
23441 }
23442
23443 final public ASTViewColumn ViewColumn() throws ParseException {
23444
23445 ASTViewColumn jjtn000 = new ASTViewColumn(this, JJTVIEWCOLUMN);
23446 boolean jjtc000 = true;
23447 jjtree.openNodeScope(jjtn000);
23448 try {
23449 ID();
23450 jjtree.closeNodeScope(jjtn000, true);
23451 jjtc000 = false;
23452 {if (true) return jjtn000 ;}
23453 } catch (Throwable jjte000) {
23454 if (jjtc000) {
23455 jjtree.clearNodeScope(jjtn000);
23456 jjtc000 = false;
23457 } else {
23458 jjtree.popNode();
23459 }
23460 if (jjte000 instanceof RuntimeException) {
23461 {if (true) throw (RuntimeException)jjte000;}
23462 }
23463 if (jjte000 instanceof ParseException) {
23464 {if (true) throw (ParseException)jjte000;}
23465 }
23466 {if (true) throw (Error)jjte000;}
23467 } finally {
23468 if (jjtc000) {
23469 jjtree.closeNodeScope(jjtn000, true);
23470 }
23471 }
23472 throw new Error("Missing return statement in function");
23473 }
23474
23475 final public ASTComment Comment() throws ParseException {
23476
23477 ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
23478 boolean jjtc000 = true;
23479 jjtree.openNodeScope(jjtn000);
23480 try {
23481 jj_consume_token(COMMENT);
23482 jj_consume_token(ON);
23483 switch (jj_nt.kind) {
23484 case INDEXTYPE:
23485 case OPERATOR:
23486 case TABLE:
23487 switch (jj_nt.kind) {
23488 case TABLE:
23489 jj_consume_token(TABLE);
23490 break;
23491 case OPERATOR:
23492 jj_consume_token(OPERATOR);
23493 break;
23494 case INDEXTYPE:
23495 jj_consume_token(INDEXTYPE);
23496 break;
23497 default:
23498 jj_la1[322] = jj_gen;
23499 jj_consume_token(-1);
23500 throw new ParseException();
23501 }
23502 if (jj_2_61(2)) {
23503 ID();
23504 jj_consume_token(3);
23505 } else {
23506 ;
23507 }
23508 ID();
23509 break;
23510 case COLUMN:
23511 jj_consume_token(COLUMN);
23512 if (jj_2_62(2147483647)) {
23513 ID();
23514 jj_consume_token(3);
23515 } else {
23516 ;
23517 }
23518 ID();
23519 jj_consume_token(3);
23520 ID();
23521 break;
23522 default:
23523 jj_la1[323] = jj_gen;
23524 jj_consume_token(-1);
23525 throw new ParseException();
23526 }
23527 jj_consume_token(IS);
23528 jj_consume_token(STRING_LITERAL);
23529 switch (jj_nt.kind) {
23530 case 4:
23531 jj_consume_token(4);
23532 break;
23533 default:
23534 jj_la1[324] = jj_gen;
23535 ;
23536 }
23537 jjtree.closeNodeScope(jjtn000, true);
23538 jjtc000 = false;
23539 {if (true) return jjtn000 ;}
23540 } catch (Throwable jjte000) {
23541 if (jjtc000) {
23542 jjtree.clearNodeScope(jjtn000);
23543 jjtc000 = false;
23544 } else {
23545 jjtree.popNode();
23546 }
23547 if (jjte000 instanceof RuntimeException) {
23548 {if (true) throw (RuntimeException)jjte000;}
23549 }
23550 if (jjte000 instanceof ParseException) {
23551 {if (true) throw (ParseException)jjte000;}
23552 }
23553 {if (true) throw (Error)jjte000;}
23554 } finally {
23555 if (jjtc000) {
23556 jjtree.closeNodeScope(jjtn000, true);
23557 }
23558 }
23559 throw new Error("Missing return statement in function");
23560 }
23561
23562
23563 final public ASTTypeMethod TypeMethod() throws ParseException {
23564
23565 ASTTypeMethod jjtn000 = new ASTTypeMethod(this, JJTTYPEMETHOD);
23566 boolean jjtc000 = true;
23567 jjtree.openNodeScope(jjtn000);
23568 try {
23569 getToken(1);
23570
23571
23572 label_73:
23573 while (true) {
23574 switch (jj_nt.kind) {
23575 case FINAL:
23576 case INSTANTIABLE:
23577 case NOT:
23578 case OVERRIDING:
23579 ;
23580 break;
23581 default:
23582 jj_la1[325] = jj_gen;
23583 break label_73;
23584 }
23585 switch (jj_nt.kind) {
23586 case NOT:
23587 jj_consume_token(NOT);
23588 break;
23589 default:
23590 jj_la1[326] = jj_gen;
23591 ;
23592 }
23593 switch (jj_nt.kind) {
23594 case OVERRIDING:
23595 jj_consume_token(OVERRIDING);
23596 break;
23597 case INSTANTIABLE:
23598 jj_consume_token(INSTANTIABLE);
23599 break;
23600 case FINAL:
23601 jj_consume_token(FINAL);
23602 break;
23603 default:
23604 jj_la1[327] = jj_gen;
23605 jj_consume_token(-1);
23606 throw new ParseException();
23607 }
23608 }
23609 switch (jj_nt.kind) {
23610 case MAP:
23611 case ORDER:
23612 switch (jj_nt.kind) {
23613 case MAP:
23614 jj_consume_token(MAP);
23615 break;
23616 case ORDER:
23617 jj_consume_token(ORDER);
23618 break;
23619 default:
23620 jj_la1[328] = jj_gen;
23621 jj_consume_token(-1);
23622 throw new ParseException();
23623 }
23624 break;
23625 default:
23626 jj_la1[329] = jj_gen;
23627 ;
23628 }
23629 switch (jj_nt.kind) {
23630 case CONSTRUCTOR:
23631 jj_consume_token(CONSTRUCTOR);
23632 break;
23633 case MEMBER:
23634 jj_consume_token(MEMBER);
23635 break;
23636 case STATIC:
23637 jj_consume_token(STATIC);
23638 break;
23639 default:
23640 jj_la1[330] = jj_gen;
23641 jj_consume_token(-1);
23642 throw new ParseException();
23643 }
23644 MethodDeclarator();
23645 switch (jj_nt.kind) {
23646 case DETERMINISTIC:
23647 jj_consume_token(DETERMINISTIC);
23648 break;
23649 default:
23650 jj_la1[331] = jj_gen;
23651 ;
23652 }
23653 switch (jj_nt.kind) {
23654 case PARALLEL_ENABLE:
23655 jj_consume_token(PARALLEL_ENABLE);
23656 break;
23657 default:
23658 jj_la1[332] = jj_gen;
23659 ;
23660 }
23661 switch (jj_nt.kind) {
23662 case PIPELINED:
23663 jj_consume_token(PIPELINED);
23664 break;
23665 default:
23666 jj_la1[333] = jj_gen;
23667 ;
23668 }
23669 switch (jj_nt.kind) {
23670 case RESULT_CACHE:
23671 jj_consume_token(RESULT_CACHE);
23672 break;
23673 default:
23674 jj_la1[334] = jj_gen;
23675 ;
23676 }
23677 switch (jj_nt.kind) {
23678 case AS:
23679 case IS:
23680 switch (jj_nt.kind) {
23681 case IS:
23682 jj_consume_token(IS);
23683 break;
23684 case AS:
23685 jj_consume_token(AS);
23686 break;
23687 default:
23688 jj_la1[335] = jj_gen;
23689 jj_consume_token(-1);
23690 throw new ParseException();
23691 }
23692 switch (jj_nt.kind) {
23693 case LANGUAGE:
23694 case EXTERNAL:
23695 CallSpecTail();
23696 switch (jj_nt.kind) {
23697 case 4:
23698 jj_consume_token(4);
23699 break;
23700 default:
23701 jj_la1[336] = jj_gen;
23702 ;
23703 }
23704 break;
23705 case REPLACE:
23706 case DEFINER:
23707 case CURRENT_USER:
23708 case SERIALLY_REUSABLE:
23709 case RESTRICT_REFERENCES:
23710 case EXCEPTION_INIT:
23711 case AUTONOMOUS_TRANSACTION:
23712 case INLINE:
23713 case ADD:
23714 case AGGREGATE:
23715 case ALL:
23716 case ALTER:
23717 case AND:
23718 case ANY:
23719 case ARRAY:
23720 case AS:
23721 case ASC:
23722 case AT:
23723 case ATTRIBUTE:
23724 case AUTHID:
23725 case AVG:
23726 case BEGIN:
23727 case BETWEEN:
23728 case BINARY_INTEGER:
23729 case BODY:
23730 case BOOLEAN:
23731 case BULK:
23732 case BY:
23733 case BYTE:
23734 case CASCADE:
23735 case CASE:
23736 case CHAR:
23737 case CHAR_BASE:
23738 case CHECK:
23739 case CLOSE:
23740 case CLUSTER:
23741 case COALESCE:
23742 case COLLECT:
23743 case COLUMN:
23744 case COMMENT:
23745 case COMMIT:
23746 case COMPRESS:
23747 case CONNECT:
23748 case CONSTANT:
23749 case CONSTRUCTOR:
23750 case CONTINUE:
23751 case CONVERT:
23752 case CREATE:
23753 case CURRENT:
23754 case CURRVAL:
23755 case CURSOR:
23756 case DATA:
23757 case DATE:
23758 case DAY:
23759 case DECLARE:
23760 case DECIMAL:
23761 case _DEFAULT:
23762 case DELETE:
23763 case DESC:
23764 case DISABLE:
23765 case DISTINCT:
23766 case DO:
23767 case DROP:
23768 case EDITIONABLE:
23769 case ELEMENT:
23770 case ELSE:
23771 case ELSIF:
23772 case ENABLE:
23773 case ESCAPE:
23774 case EXCEPT:
23775 case EXCEPTION:
23776 case EXCEPTIONS:
23777 case EXCLUSIVE:
23778 case EXECUTE:
23779 case EXISTS:
23780 case EXIT:
23781 case EXTENDS:
23782 case EXTRACT:
23783 case FALSE:
23784 case FETCH:
23785 case FINAL:
23786 case FLOAT:
23787 case FOR:
23788 case FORALL:
23789 case FORCE:
23790 case FROM:
23791 case FUNCTION:
23792 case GLOBAL:
23793 case GOTO:
23794 case GROUP:
23795 case HASH:
23796 case HAVING:
23797 case HEAP:
23798 case HOUR:
23799 case IF:
23800 case IMMEDIATE:
23801 case IN:
23802 case INDEX:
23803 case INDICES:
23804 case INDEXTYPE:
23805 case INDICATOR:
23806 case INSERT:
23807 case INSTANTIABLE:
23808 case INTEGER:
23809 case INTERFACE:
23810 case INTERSECT:
23811 case INTERVAL:
23812 case INTO:
23813 case INVALIDATE:
23814 case IS:
23815 case ISOLATION:
23816 case JAVA:
23817 case LEVEL:
23818 case LIKE:
23819 case LIMIT:
23820 case LIMITED:
23821 case LOCK:
23822 case LONG:
23823 case LOOP:
23824 case MAP:
23825 case MAX:
23826 case MEMBER:
23827 case MERGE:
23828 case MIN:
23829 case MINUS:
23830 case MINUTE:
23831 case MLSLABEL:
23832 case MODIFY:
23833 case MOD:
23834 case MODE:
23835 case MONTH:
23836 case NATURAL:
23837 case NATURALN:
23838 case NEW:
23839 case NEXTVAL:
23840 case NO:
23841 case NOCOPY:
23842 case NONEDITIONABLE:
23843 case NOT:
23844 case NOWAIT:
23845 case NULL:
23846 case NULLIF:
23847 case NUMBER:
23848 case BFILE_BASE:
23849 case BLOB_BASE:
23850 case CLOB_BASE:
23851 case DATE_BASE:
23852 case NUMBER_BASE:
23853 case OBJECT:
23854 case OCIROWID:
23855 case OF:
23856 case OID:
23857 case ON:
23858 case OPAQUE:
23859 case OPEN:
23860 case OPERATOR:
23861 case OPTION:
23862 case OR:
23863 case ORDER:
23864 case ORGANIZATION:
23865 case OTHERS:
23866 case OUT:
23867 case OVERRIDING:
23868 case PACKAGE:
23869 case PARTITION:
23870 case PCTFREE:
23871 case PLS_INTEGER:
23872 case POSITIVE:
23873 case POSITIVEN:
23874 case PRAGMA:
23875 case PRESERVE:
23876 case PRIOR:
23877 case PROMPT:
23878 case PRIVATE:
23879 case PROCEDURE:
23880 case PUBLIC:
23881 case RAISE:
23882 case RANGE:
23883 case RAW:
23884 case REAL:
23885 case RECORD:
23886 case REF:
23887 case RELEASE:
23888 case RELIES_ON:
23889 case RENAME:
23890 case RESULT:
23891 case RETURN:
23892 case RETURNING:
23893 case REVERSE:
23894 case ROLLBACK:
23895 case ROW:
23896 case ROWS:
23897 case ROWID:
23898 case ROWNUM:
23899 case ROWTYPE:
23900 case SAVE:
23901 case SAVEPOINT:
23902 case SECOND:
23903 case SELECT:
23904 case SELF:
23905 case SEPARATE:
23906 case SET:
23907 case SHARE:
23908 case SMALLINT:
23909 case SPACE:
23910 case SQL:
23911 case SQLCODE:
23912 case SQLERRM:
23913 case START:
23914 case STATIC:
23915 case STDDEV:
23916 case SUBTYPE:
23917 case SUBSTITUTABLE:
23918 case SUCCESSFUL:
23919 case SUM:
23920 case SYNONYM:
23921 case SYSDATE:
23922 case SYS_REFCURSOR:
23923 case TABLE:
23924 case TEMPORARY:
23925 case THEN:
23926 case TIME:
23927 case TIMESTAMP:
23928 case TIMEZONE_REGION:
23929 case TIMEZONE_ABBR:
23930 case TIMEZONE_MINUTE:
23931 case TIMEZONE_HOUR:
23932 case TO:
23933 case TRANSACTION:
23934 case TRIGGER:
23935 case TRUE:
23936 case TYPE:
23937 case UI:
23938 case UNDER:
23939 case USING:
23940 case WHILE:
23941 case YES:
23942 case SHOW:
23943 case A:
23944 case UPDATE:
23945 case VARCHAR:
23946 case VARCHAR2:
23947 case DOUBLE:
23948 case DEC:
23949 case PRECISION:
23950 case INT:
23951 case NUMERIC:
23952 case SIGNTYPE:
23953 case NCHAR:
23954 case NVARCHAR2:
23955 case STRING:
23956 case UROWID:
23957 case VARRAY:
23958 case VARYING:
23959 case BFILE:
23960 case BLOB:
23961 case CLOB:
23962 case NCLOB:
23963 case YEAR:
23964 case LOCAL:
23965 case WITH:
23966 case ZONE:
23967 case CHARACTER:
23968 case AFTER:
23969 case BEFORE:
23970 case OLD:
23971 case PARENT:
23972 case CC_IF:
23973 case ANALYZE:
23974 case ASSOCIATE:
23975 case AUDIT:
23976 case COMPOUND:
23977 case DATABASE:
23978 case CALL:
23979 case DDL:
23980 case DISASSOCIATE:
23981 case EACH:
23982 case FOLLOWS:
23983 case LOGOFF:
23984 case LOGON:
23985 case NESTED:
23986 case NOAUDIT:
23987 case SCHEMA:
23988 case SERVERERROR:
23989 case SHUTDOWN:
23990 case STARTUP:
23991 case STATEMENT:
23992 case STATISTICS:
23993 case SUSPEND:
23994 case TRUNCATE:
23995 case WRAPPED:
23996 case LIBRARY:
23997 case NAME:
23998 case STRUCT:
23999 case CONTEXT:
24000 case PARAMETERS:
24001 case LENGTH:
24002 case TDO:
24003 case MAXLEN:
24004 case CHARSETID:
24005 case CHARSETFORM:
24006 case ACCEPT:
24007 case ACCESSIBLE:
24008 case COPY:
24009 case DEFINE:
24010 case DISCONNECT:
24011 case HOST:
24012 case PRINT:
24013 case QUIT:
24014 case REMARK:
24015 case UNDEFINE:
24016 case VARIABLE:
24017 case WHENEVER:
24018 case ATTACH:
24019 case CAST:
24020 case TREAT:
24021 case TRIM:
24022 case LEFT:
24023 case RIGHT:
24024 case BOTH:
24025 case EMPTY:
24026 case MULTISET:
24027 case SUBMULTISET:
24028 case LEADING:
24029 case TRAILING:
24030 case CHAR_CS:
24031 case NCHAR_CS:
24032 case DBTIMEZONE:
24033 case SESSIONTIMEZONE:
24034 case AUTHENTICATED:
24035 case LINK:
24036 case SHARED:
24037 case DIRECTORY:
24038 case USER:
24039 case IDENTIFIER:
24040 case QUOTED_LITERAL:
24041 case SQLDATA_CLASS:
24042 case CUSTOMDATUM_CLASS:
24043 case ORADATA_CLASS:
24044 case JAVA_INTERFACE_CLASS:
24045 DeclarativeSection();
24046 jj_consume_token(BEGIN);
24047 label_74:
24048 while (true) {
24049 switch (jj_nt.kind) {
24050 case 5:
24051 case 16:
24052 case 17:
24053 case 21:
24054 case REPLACE:
24055 case DEFINER:
24056 case CURRENT_USER:
24057 case LANGUAGE:
24058 case INLINE:
24059 case ADD:
24060 case AGGREGATE:
24061 case ARRAY:
24062 case AT:
24063 case ATTRIBUTE:
24064 case AUTHID:
24065 case BEGIN:
24066 case BODY:
24067 case BULK:
24068 case BYTE:
24069 case CASCADE:
24070 case CASE:
24071 case CLOSE:
24072 case COALESCE:
24073 case COLLECT:
24074 case COLUMN:
24075 case COMMENT:
24076 case COMMIT:
24077 case CONSTRUCTOR:
24078 case CONTINUE:
24079 case CONVERT:
24080 case CURRENT:
24081 case CURSOR:
24082 case DATA:
24083 case DATE:
24084 case DAY:
24085 case DECLARE:
24086 case DELETE:
24087 case DISABLE:
24088 case EDITIONABLE:
24089 case ELEMENT:
24090 case ENABLE:
24091 case ESCAPE:
24092 case EXCEPT:
24093 case EXCEPTIONS:
24094 case EXECUTE:
24095 case EXIT:
24096 case EXTERNAL:
24097 case EXTENDS:
24098 case EXTRACT:
24099 case FALSE:
24100 case FETCH:
24101 case FINAL:
24102 case FOR:
24103 case FORALL:
24104 case FORCE:
24105 case FUNCTION:
24106 case GLOBAL:
24107 case GOTO:
24108 case HASH:
24109 case HEAP:
24110 case HOUR:
24111 case IF:
24112 case IMMEDIATE:
24113 case INDICES:
24114 case INDEXTYPE:
24115 case INDICATOR:
24116 case INSERT:
24117 case INSTANTIABLE:
24118 case INTERVAL:
24119 case INVALIDATE:
24120 case ISOLATION:
24121 case JAVA:
24122 case LEVEL:
24123 case LIMIT:
24124 case LOCK:
24125 case LOOP:
24126 case MAP:
24127 case MAX:
24128 case MEMBER:
24129 case MERGE:
24130 case MIN:
24131 case MINUTE:
24132 case MLSLABEL:
24133 case MODIFY:
24134 case MOD:
24135 case MONTH:
24136 case NATURAL:
24137 case NEW:
24138 case NEW_DOT:
24139 case NO:
24140 case NONEDITIONABLE:
24141 case NOT:
24142 case NULL:
24143 case NULLIF:
24144 case OBJECT:
24145 case OID:
24146 case OPAQUE:
24147 case OPEN:
24148 case OPERATOR:
24149 case ORGANIZATION:
24150 case OTHERS:
24151 case OVERRIDING:
24152 case PACKAGE:
24153 case PARTITION:
24154 case PIPE:
24155 case PRAGMA:
24156 case PRESERVE:
24157 case PRIVATE:
24158 case PROCEDURE:
24159 case RAISE:
24160 case RANGE:
24161 case RAW:
24162 case REAL:
24163 case RECORD:
24164 case REF:
24165 case RELEASE:
24166 case RELIES_ON:
24167 case RENAME:
24168 case RESULT:
24169 case RETURN:
24170 case RETURNING:
24171 case REVERSE:
24172 case ROLLBACK:
24173 case ROW:
24174 case ROWS:
24175 case ROWID:
24176 case ROWNUM:
24177 case SAVE:
24178 case SAVEPOINT:
24179 case SECOND:
24180 case SELECT:
24181 case SELF:
24182 case SET:
24183 case SPACE:
24184 case SQL:
24185 case SQLCODE:
24186 case SQLERRM:
24187 case STATIC:
24188 case SUBTYPE:
24189 case SUBSTITUTABLE:
24190 case SUCCESSFUL:
24191 case SYSDATE:
24192 case SYS_REFCURSOR:
24193 case TEMPORARY:
24194 case TIME:
24195 case TIMESTAMP:
24196 case TIMEZONE_REGION:
24197 case TIMEZONE_ABBR:
24198 case TIMEZONE_MINUTE:
24199 case TIMEZONE_HOUR:
24200 case TRANSACTION:
24201 case TRUE:
24202 case TYPE:
24203 case UNDER:
24204 case USING:
24205 case WHILE:
24206 case YES:
24207 case SHOW:
24208 case A:
24209 case UPDATE:
24210 case DOUBLE:
24211 case DEC:
24212 case PRECISION:
24213 case INT:
24214 case NUMERIC:
24215 case NCHAR:
24216 case NVARCHAR2:
24217 case STRING:
24218 case UROWID:
24219 case VARRAY:
24220 case VARYING:
24221 case BFILE:
24222 case BLOB:
24223 case CLOB:
24224 case NCLOB:
24225 case YEAR:
24226 case LOCAL:
24227 case WITH:
24228 case ZONE:
24229 case CHARACTER:
24230 case AFTER:
24231 case BEFORE:
24232 case OLD:
24233 case PARENT:
24234 case CC_IF:
24235 case CC_ERROR:
24236 case ANALYZE:
24237 case ASSOCIATE:
24238 case AUDIT:
24239 case COMPOUND:
24240 case DATABASE:
24241 case CALL:
24242 case DDL:
24243 case DISASSOCIATE:
24244 case EACH:
24245 case FOLLOWS:
24246 case LOGOFF:
24247 case LOGON:
24248 case NESTED:
24249 case NOAUDIT:
24250 case SCHEMA:
24251 case SERVERERROR:
24252 case SHUTDOWN:
24253 case STARTUP:
24254 case STATEMENT:
24255 case STATISTICS:
24256 case SUSPEND:
24257 case TRUNCATE:
24258 case WRAPPED:
24259 case LIBRARY:
24260 case NAME:
24261 case STRUCT:
24262 case CONTEXT:
24263 case PARAMETERS:
24264 case LENGTH:
24265 case TDO:
24266 case MAXLEN:
24267 case CHARSETID:
24268 case CHARSETFORM:
24269 case ACCEPT:
24270 case ACCESSIBLE:
24271 case COPY:
24272 case DEFINE:
24273 case DISCONNECT:
24274 case HOST:
24275 case PRINT:
24276 case QUIT:
24277 case REMARK:
24278 case UNDEFINE:
24279 case VARIABLE:
24280 case WHENEVER:
24281 case ATTACH:
24282 case CAST:
24283 case TREAT:
24284 case TRIM:
24285 case LEFT:
24286 case RIGHT:
24287 case BOTH:
24288 case EMPTY:
24289 case MULTISET:
24290 case SUBMULTISET:
24291 case LEADING:
24292 case TRAILING:
24293 case CHAR_CS:
24294 case NCHAR_CS:
24295 case DBTIMEZONE:
24296 case SESSIONTIMEZONE:
24297 case AUTHENTICATED:
24298 case LINK:
24299 case SHARED:
24300 case DIRECTORY:
24301 case USER:
24302 case IDENTIFIER:
24303 case UNSIGNED_NUMERIC_LITERAL:
24304 case CHARACTER_LITERAL:
24305 case STRING_LITERAL:
24306 case QUOTED_LITERAL:
24307 ;
24308 break;
24309 default:
24310 jj_la1[337] = jj_gen;
24311 break label_74;
24312 }
24313 Statement();
24314 }
24315 switch (jj_nt.kind) {
24316 case EXCEPTION:
24317 ExceptionHandler();
24318 break;
24319 default:
24320 jj_la1[338] = jj_gen;
24321 ;
24322 }
24323 jj_consume_token(END);
24324 switch (jj_nt.kind) {
24325 case REPLACE:
24326 case DEFINER:
24327 case CURRENT_USER:
24328 case SERIALLY_REUSABLE:
24329 case RESTRICT_REFERENCES:
24330 case EXCEPTION_INIT:
24331 case AUTONOMOUS_TRANSACTION:
24332 case LANGUAGE:
24333 case INLINE:
24334 case ADD:
24335 case AGGREGATE:
24336 case ALL:
24337 case ALTER:
24338 case AND:
24339 case ANY:
24340 case ARRAY:
24341 case AS:
24342 case ASC:
24343 case AT:
24344 case ATTRIBUTE:
24345 case AUTHID:
24346 case AVG:
24347 case BETWEEN:
24348 case BINARY_INTEGER:
24349 case BODY:
24350 case BOOLEAN:
24351 case BULK:
24352 case BY:
24353 case BYTE:
24354 case CASCADE:
24355 case CASE:
24356 case CHAR:
24357 case CHAR_BASE:
24358 case CHECK:
24359 case CLOSE:
24360 case CLUSTER:
24361 case COALESCE:
24362 case COLLECT:
24363 case COLUMN:
24364 case COMMENT:
24365 case COMMIT:
24366 case COMPRESS:
24367 case CONNECT:
24368 case CONSTANT:
24369 case CONSTRUCTOR:
24370 case CONTINUE:
24371 case CONVERT:
24372 case CREATE:
24373 case CURRENT:
24374 case CURRVAL:
24375 case CURSOR:
24376 case DATA:
24377 case DATE:
24378 case DAY:
24379 case DECLARE:
24380 case DECIMAL:
24381 case _DEFAULT:
24382 case DELETE:
24383 case DESC:
24384 case DISABLE:
24385 case DISTINCT:
24386 case DO:
24387 case DROP:
24388 case EDITIONABLE:
24389 case ELEMENT:
24390 case ELSE:
24391 case ELSIF:
24392 case ENABLE:
24393 case ESCAPE:
24394 case EXCEPT:
24395 case EXCEPTION:
24396 case EXCEPTIONS:
24397 case EXCLUSIVE:
24398 case EXECUTE:
24399 case EXISTS:
24400 case EXIT:
24401 case EXTERNAL:
24402 case EXTENDS:
24403 case EXTRACT:
24404 case FALSE:
24405 case FETCH:
24406 case FINAL:
24407 case FLOAT:
24408 case FOR:
24409 case FORALL:
24410 case FORCE:
24411 case FROM:
24412 case FUNCTION:
24413 case GLOBAL:
24414 case GOTO:
24415 case GROUP:
24416 case HASH:
24417 case HAVING:
24418 case HEAP:
24419 case HOUR:
24420 case IF:
24421 case IMMEDIATE:
24422 case IN:
24423 case INDEX:
24424 case INDICES:
24425 case INDEXTYPE:
24426 case INDICATOR:
24427 case INSERT:
24428 case INSTANTIABLE:
24429 case INTEGER:
24430 case INTERFACE:
24431 case INTERSECT:
24432 case INTERVAL:
24433 case INTO:
24434 case INVALIDATE:
24435 case IS:
24436 case ISOLATION:
24437 case JAVA:
24438 case LEVEL:
24439 case LIKE:
24440 case LIMIT:
24441 case LIMITED:
24442 case LOCK:
24443 case LONG:
24444 case LOOP:
24445 case MAP:
24446 case MAX:
24447 case MEMBER:
24448 case MERGE:
24449 case MIN:
24450 case MINUS:
24451 case MINUTE:
24452 case MLSLABEL:
24453 case MODIFY:
24454 case MOD:
24455 case MODE:
24456 case MONTH:
24457 case NATURAL:
24458 case NATURALN:
24459 case NEW:
24460 case NEXTVAL:
24461 case NO:
24462 case NOCOPY:
24463 case NONEDITIONABLE:
24464 case NOT:
24465 case NOWAIT:
24466 case NULL:
24467 case NULLIF:
24468 case NUMBER:
24469 case BFILE_BASE:
24470 case BLOB_BASE:
24471 case CLOB_BASE:
24472 case DATE_BASE:
24473 case NUMBER_BASE:
24474 case OBJECT:
24475 case OCIROWID:
24476 case OF:
24477 case OID:
24478 case ON:
24479 case OPAQUE:
24480 case OPEN:
24481 case OPERATOR:
24482 case OPTION:
24483 case OR:
24484 case ORDER:
24485 case ORGANIZATION:
24486 case OTHERS:
24487 case OUT:
24488 case OVERRIDING:
24489 case PACKAGE:
24490 case PARTITION:
24491 case PCTFREE:
24492 case PLS_INTEGER:
24493 case POSITIVE:
24494 case POSITIVEN:
24495 case PRESERVE:
24496 case PRIOR:
24497 case PROMPT:
24498 case PRIVATE:
24499 case PROCEDURE:
24500 case PUBLIC:
24501 case RAISE:
24502 case RANGE:
24503 case RAW:
24504 case REAL:
24505 case RECORD:
24506 case REF:
24507 case RELEASE:
24508 case RELIES_ON:
24509 case RENAME:
24510 case RESULT:
24511 case RETURN:
24512 case RETURNING:
24513 case REVERSE:
24514 case ROLLBACK:
24515 case ROW:
24516 case ROWS:
24517 case ROWID:
24518 case ROWNUM:
24519 case ROWTYPE:
24520 case SAVE:
24521 case SAVEPOINT:
24522 case SECOND:
24523 case SELECT:
24524 case SELF:
24525 case SEPARATE:
24526 case SET:
24527 case SHARE:
24528 case SMALLINT:
24529 case SPACE:
24530 case SQL:
24531 case SQLCODE:
24532 case SQLERRM:
24533 case START:
24534 case STATIC:
24535 case STDDEV:
24536 case SUBTYPE:
24537 case SUBSTITUTABLE:
24538 case SUCCESSFUL:
24539 case SUM:
24540 case SYNONYM:
24541 case SYSDATE:
24542 case SYS_REFCURSOR:
24543 case TABLE:
24544 case TEMPORARY:
24545 case THEN:
24546 case TIME:
24547 case TIMESTAMP:
24548 case TIMEZONE_REGION:
24549 case TIMEZONE_ABBR:
24550 case TIMEZONE_MINUTE:
24551 case TIMEZONE_HOUR:
24552 case TO:
24553 case TRANSACTION:
24554 case TRIGGER:
24555 case TRUE:
24556 case TYPE:
24557 case UI:
24558 case UNDER:
24559 case USING:
24560 case WHILE:
24561 case YES:
24562 case SHOW:
24563 case A:
24564 case UPDATE:
24565 case VARCHAR:
24566 case VARCHAR2:
24567 case DOUBLE:
24568 case DEC:
24569 case PRECISION:
24570 case INT:
24571 case NUMERIC:
24572 case SIGNTYPE:
24573 case NCHAR:
24574 case NVARCHAR2:
24575 case STRING:
24576 case UROWID:
24577 case VARRAY:
24578 case VARYING:
24579 case BFILE:
24580 case BLOB:
24581 case CLOB:
24582 case NCLOB:
24583 case YEAR:
24584 case LOCAL:
24585 case WITH:
24586 case ZONE:
24587 case CHARACTER:
24588 case AFTER:
24589 case BEFORE:
24590 case OLD:
24591 case PARENT:
24592 case ANALYZE:
24593 case ASSOCIATE:
24594 case AUDIT:
24595 case COMPOUND:
24596 case DATABASE:
24597 case CALL:
24598 case DDL:
24599 case DISASSOCIATE:
24600 case EACH:
24601 case FOLLOWS:
24602 case LOGOFF:
24603 case LOGON:
24604 case NESTED:
24605 case NOAUDIT:
24606 case SCHEMA:
24607 case SERVERERROR:
24608 case SHUTDOWN:
24609 case STARTUP:
24610 case STATEMENT:
24611 case STATISTICS:
24612 case SUSPEND:
24613 case TRUNCATE:
24614 case WRAPPED:
24615 case LIBRARY:
24616 case NAME:
24617 case STRUCT:
24618 case CONTEXT:
24619 case PARAMETERS:
24620 case LENGTH:
24621 case TDO:
24622 case MAXLEN:
24623 case CHARSETID:
24624 case CHARSETFORM:
24625 case ACCEPT:
24626 case ACCESSIBLE:
24627 case COPY:
24628 case DEFINE:
24629 case DISCONNECT:
24630 case HOST:
24631 case PRINT:
24632 case QUIT:
24633 case REMARK:
24634 case UNDEFINE:
24635 case VARIABLE:
24636 case WHENEVER:
24637 case ATTACH:
24638 case CAST:
24639 case TREAT:
24640 case TRIM:
24641 case LEFT:
24642 case RIGHT:
24643 case BOTH:
24644 case EMPTY:
24645 case MULTISET:
24646 case SUBMULTISET:
24647 case LEADING:
24648 case TRAILING:
24649 case CHAR_CS:
24650 case NCHAR_CS:
24651 case DBTIMEZONE:
24652 case SESSIONTIMEZONE:
24653 case AUTHENTICATED:
24654 case LINK:
24655 case SHARED:
24656 case DIRECTORY:
24657 case USER:
24658 case IDENTIFIER:
24659 case QUOTED_LITERAL:
24660 case SQLDATA_CLASS:
24661 case CUSTOMDATUM_CLASS:
24662 case ORADATA_CLASS:
24663 case JAVA_INTERFACE_CLASS:
24664 ID();
24665 break;
24666 default:
24667 jj_la1[339] = jj_gen;
24668 ;
24669 }
24670 jj_consume_token(4);
24671 break;
24672 default:
24673 jj_la1[340] = jj_gen;
24674 jj_consume_token(-1);
24675 throw new ParseException();
24676 }
24677 break;
24678 default:
24679 jj_la1[341] = jj_gen;
24680 ;
24681 }
24682 jjtree.closeNodeScope(jjtn000, true);
24683 jjtc000 = false;
24684 {if (true) return jjtn000 ;}
24685 } catch (Throwable jjte000) {
24686 if (jjtc000) {
24687 jjtree.clearNodeScope(jjtn000);
24688 jjtc000 = false;
24689 } else {
24690 jjtree.popNode();
24691 }
24692 if (jjte000 instanceof RuntimeException) {
24693 {if (true) throw (RuntimeException)jjte000;}
24694 }
24695 if (jjte000 instanceof ParseException) {
24696 {if (true) throw (ParseException)jjte000;}
24697 }
24698 {if (true) throw (Error)jjte000;}
24699 } finally {
24700 if (jjtc000) {
24701 jjtree.closeNodeScope(jjtn000, true);
24702 }
24703 }
24704 throw new Error("Missing return statement in function");
24705 }
24706
24707 final public ASTTypeSpecification TypeSpecification() throws ParseException {
24708
24709 ASTTypeSpecification jjtn000 = new ASTTypeSpecification(this, JJTTYPESPECIFICATION);
24710 boolean jjtc000 = true;
24711 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
24712 try {
24713 switch (jj_nt.kind) {
24714 case CREATE:
24715 jj_consume_token(CREATE);
24716 switch (jj_nt.kind) {
24717 case OR:
24718 jj_consume_token(OR);
24719 jj_consume_token(REPLACE);
24720 break;
24721 default:
24722 jj_la1[342] = jj_gen;
24723 ;
24724 }
24725 switch (jj_nt.kind) {
24726 case EDITIONABLE:
24727 case NONEDITIONABLE:
24728 switch (jj_nt.kind) {
24729 case EDITIONABLE:
24730 jj_consume_token(EDITIONABLE);
24731 break;
24732 case NONEDITIONABLE:
24733 jj_consume_token(NONEDITIONABLE);
24734 break;
24735 default:
24736 jj_la1[343] = jj_gen;
24737 jj_consume_token(-1);
24738 throw new ParseException();
24739 }
24740 break;
24741 default:
24742 jj_la1[344] = jj_gen;
24743 ;
24744 }
24745 break;
24746 default:
24747 jj_la1[345] = jj_gen;
24748 ;
24749 }
24750 jj_consume_token(TYPE);
24751 simpleNode = ObjectNameDeclaration();
24752 switch (jj_nt.kind) {
24753 case FORCE:
24754 jj_consume_token(FORCE);
24755 break;
24756 default:
24757 jj_la1[346] = jj_gen;
24758 ;
24759 }
24760 if (jj_2_63(2)) {
24761 jj_consume_token(OID);
24762 jj_consume_token(STRING_LITERAL);
24763 } else {
24764 ;
24765 }
24766 label_75:
24767 while (true) {
24768 if (jj_2_64(2)) {
24769 ;
24770 } else {
24771 break label_75;
24772 }
24773 switch (jj_nt.kind) {
24774 case AUTHID:
24775 jj_consume_token(AUTHID);
24776 switch (jj_nt.kind) {
24777 case CURRENT_USER:
24778 jj_consume_token(CURRENT_USER);
24779 break;
24780 case DEFINER:
24781 jj_consume_token(DEFINER);
24782 break;
24783 default:
24784 jj_la1[347] = jj_gen;
24785 jj_consume_token(-1);
24786 throw new ParseException();
24787 }
24788 break;
24789 case ACCESSIBLE:
24790 AccessibleByClause();
24791 break;
24792 default:
24793 jj_la1[348] = jj_gen;
24794 jj_consume_token(-1);
24795 throw new ParseException();
24796 }
24797 }
24798 switch (jj_nt.kind) {
24799 case AS:
24800 case IS:
24801 case UNDER:
24802 switch (jj_nt.kind) {
24803 case UNDER:
24804 jj_consume_token(UNDER);
24805 ObjectNameDeclaration();
24806 break;
24807 default:
24808 jj_la1[355] = jj_gen;
24809 if (jj_2_65(2)) {
24810 switch (jj_nt.kind) {
24811 case IS:
24812 jj_consume_token(IS);
24813 break;
24814 case AS:
24815 jj_consume_token(AS);
24816 break;
24817 default:
24818 jj_la1[349] = jj_gen;
24819 jj_consume_token(-1);
24820 throw new ParseException();
24821 }
24822 jj_consume_token(OBJECT);
24823 } else if (jj_2_66(2)) {
24824 switch (jj_nt.kind) {
24825 case IS:
24826 jj_consume_token(IS);
24827 break;
24828 case AS:
24829 jj_consume_token(AS);
24830 break;
24831 default:
24832 jj_la1[350] = jj_gen;
24833 jj_consume_token(-1);
24834 throw new ParseException();
24835 }
24836 jj_consume_token(OPAQUE);
24837 jj_consume_token(VARYING);
24838 jj_consume_token(24);
24839 jj_consume_token(USING);
24840 jj_consume_token(LIBRARY);
24841 switch (jj_nt.kind) {
24842 case IDENTIFIER:
24843 jj_consume_token(IDENTIFIER);
24844 break;
24845 case QUOTED_LITERAL:
24846 jj_consume_token(QUOTED_LITERAL);
24847 break;
24848 case STRING_LITERAL:
24849 StringLiteral();
24850 break;
24851 default:
24852 jj_la1[351] = jj_gen;
24853 jj_consume_token(-1);
24854 throw new ParseException();
24855 }
24856 switch (jj_nt.kind) {
24857 case 3:
24858 jj_consume_token(3);
24859 switch (jj_nt.kind) {
24860 case IDENTIFIER:
24861 jj_consume_token(IDENTIFIER);
24862 break;
24863 case QUOTED_LITERAL:
24864 jj_consume_token(QUOTED_LITERAL);
24865 break;
24866 case STRING_LITERAL:
24867 StringLiteral();
24868 break;
24869 default:
24870 jj_la1[352] = jj_gen;
24871 jj_consume_token(-1);
24872 throw new ParseException();
24873 }
24874 break;
24875 default:
24876 jj_la1[353] = jj_gen;
24877 ;
24878 }
24879 } else if (jj_2_67(2)) {
24880 switch (jj_nt.kind) {
24881 case IS:
24882 jj_consume_token(IS);
24883 break;
24884 case AS:
24885 jj_consume_token(AS);
24886 break;
24887 default:
24888 jj_la1[354] = jj_gen;
24889 jj_consume_token(-1);
24890 throw new ParseException();
24891 }
24892 CollectionTypeName();
24893 jj_consume_token(OF);
24894 Datatype();
24895 } else {
24896 jj_consume_token(-1);
24897 throw new ParseException();
24898 }
24899 }
24900 break;
24901 default:
24902 jj_la1[356] = jj_gen;
24903 ;
24904 }
24905 if (jj_2_68(8)) {
24906 jj_consume_token(EXTERNAL);
24907 jj_consume_token(IDENTIFIER);
24908 jj_consume_token(IDENTIFIER);
24909 jj_consume_token(LANGUAGE);
24910 jj_consume_token(JAVA);
24911 jj_consume_token(USING);
24912 jj_consume_token(IDENTIFIER);
24913 } else {
24914 ;
24915 }
24916 switch (jj_nt.kind) {
24917 case WRAPPED:
24918 WrappedObject();
24919 break;
24920 default:
24921 jj_la1[357] = jj_gen;
24922 ;
24923 }
24924 switch (jj_nt.kind) {
24925 case 5:
24926 jj_consume_token(5);
24927 label_76:
24928 while (true) {
24929 switch (jj_nt.kind) {
24930 case REPLACE:
24931 case DEFINER:
24932 case CURRENT_USER:
24933 case SERIALLY_REUSABLE:
24934 case RESTRICT_REFERENCES:
24935 case EXCEPTION_INIT:
24936 case AUTONOMOUS_TRANSACTION:
24937 case LANGUAGE:
24938 case INLINE:
24939 case ADD:
24940 case AGGREGATE:
24941 case ALL:
24942 case ALTER:
24943 case AND:
24944 case ANY:
24945 case ARRAY:
24946 case AS:
24947 case ASC:
24948 case AT:
24949 case ATTRIBUTE:
24950 case AUTHID:
24951 case AVG:
24952 case BETWEEN:
24953 case BINARY_INTEGER:
24954 case BODY:
24955 case BOOLEAN:
24956 case BULK:
24957 case BY:
24958 case BYTE:
24959 case CASCADE:
24960 case CASE:
24961 case CHAR:
24962 case CHAR_BASE:
24963 case CHECK:
24964 case CLOSE:
24965 case CLUSTER:
24966 case COALESCE:
24967 case COLLECT:
24968 case COLUMN:
24969 case COMMENT:
24970 case COMMIT:
24971 case COMPRESS:
24972 case CONNECT:
24973 case CONSTANT:
24974 case CONSTRUCTOR:
24975 case CONTINUE:
24976 case CONVERT:
24977 case CREATE:
24978 case CURRENT:
24979 case CURRVAL:
24980 case CURSOR:
24981 case DATA:
24982 case DATE:
24983 case DAY:
24984 case DECLARE:
24985 case DECIMAL:
24986 case _DEFAULT:
24987 case DELETE:
24988 case DESC:
24989 case DISABLE:
24990 case DISTINCT:
24991 case DO:
24992 case DROP:
24993 case EDITIONABLE:
24994 case ELEMENT:
24995 case ELSE:
24996 case ELSIF:
24997 case ENABLE:
24998 case ESCAPE:
24999 case EXCEPT:
25000 case EXCEPTION:
25001 case EXCEPTIONS:
25002 case EXCLUSIVE:
25003 case EXECUTE:
25004 case EXISTS:
25005 case EXIT:
25006 case EXTERNAL:
25007 case EXTENDS:
25008 case EXTRACT:
25009 case FALSE:
25010 case FETCH:
25011 case FINAL:
25012 case FLOAT:
25013 case FOR:
25014 case FORALL:
25015 case FORCE:
25016 case FROM:
25017 case FUNCTION:
25018 case GLOBAL:
25019 case GOTO:
25020 case GROUP:
25021 case HASH:
25022 case HAVING:
25023 case HEAP:
25024 case HOUR:
25025 case IF:
25026 case IMMEDIATE:
25027 case IN:
25028 case INDEX:
25029 case INDICES:
25030 case INDEXTYPE:
25031 case INDICATOR:
25032 case INSERT:
25033 case INSTANTIABLE:
25034 case INTEGER:
25035 case INTERFACE:
25036 case INTERSECT:
25037 case INTERVAL:
25038 case INTO:
25039 case INVALIDATE:
25040 case IS:
25041 case ISOLATION:
25042 case JAVA:
25043 case LEVEL:
25044 case LIKE:
25045 case LIMIT:
25046 case LIMITED:
25047 case LOCK:
25048 case LONG:
25049 case LOOP:
25050 case MAP:
25051 case MAX:
25052 case MEMBER:
25053 case MERGE:
25054 case MIN:
25055 case MINUS:
25056 case MINUTE:
25057 case MLSLABEL:
25058 case MODIFY:
25059 case MOD:
25060 case MODE:
25061 case MONTH:
25062 case NATURAL:
25063 case NATURALN:
25064 case NEW:
25065 case NEXTVAL:
25066 case NO:
25067 case NOCOPY:
25068 case NONEDITIONABLE:
25069 case NOT:
25070 case NOWAIT:
25071 case NULL:
25072 case NULLIF:
25073 case NUMBER:
25074 case BFILE_BASE:
25075 case BLOB_BASE:
25076 case CLOB_BASE:
25077 case DATE_BASE:
25078 case NUMBER_BASE:
25079 case OBJECT:
25080 case OCIROWID:
25081 case OF:
25082 case OID:
25083 case ON:
25084 case OPAQUE:
25085 case OPEN:
25086 case OPERATOR:
25087 case OPTION:
25088 case OR:
25089 case ORDER:
25090 case ORGANIZATION:
25091 case OTHERS:
25092 case OUT:
25093 case OVERRIDING:
25094 case PACKAGE:
25095 case PARTITION:
25096 case PCTFREE:
25097 case PLS_INTEGER:
25098 case POSITIVE:
25099 case POSITIVEN:
25100 case PRAGMA:
25101 case PRESERVE:
25102 case PRIOR:
25103 case PROMPT:
25104 case PRIVATE:
25105 case PROCEDURE:
25106 case PUBLIC:
25107 case RAISE:
25108 case RANGE:
25109 case RAW:
25110 case REAL:
25111 case RECORD:
25112 case REF:
25113 case RELEASE:
25114 case RELIES_ON:
25115 case RENAME:
25116 case RESULT:
25117 case RETURN:
25118 case RETURNING:
25119 case REVERSE:
25120 case ROLLBACK:
25121 case ROW:
25122 case ROWS:
25123 case ROWID:
25124 case ROWNUM:
25125 case ROWTYPE:
25126 case SAVE:
25127 case SAVEPOINT:
25128 case SECOND:
25129 case SELECT:
25130 case SELF:
25131 case SEPARATE:
25132 case SET:
25133 case SHARE:
25134 case SMALLINT:
25135 case SPACE:
25136 case SQL:
25137 case SQLCODE:
25138 case SQLERRM:
25139 case START:
25140 case STATIC:
25141 case STDDEV:
25142 case SUBTYPE:
25143 case SUBSTITUTABLE:
25144 case SUCCESSFUL:
25145 case SUM:
25146 case SYNONYM:
25147 case SYSDATE:
25148 case SYS_REFCURSOR:
25149 case TABLE:
25150 case TEMPORARY:
25151 case THEN:
25152 case TIME:
25153 case TIMESTAMP:
25154 case TIMEZONE_REGION:
25155 case TIMEZONE_ABBR:
25156 case TIMEZONE_MINUTE:
25157 case TIMEZONE_HOUR:
25158 case TO:
25159 case TRANSACTION:
25160 case TRIGGER:
25161 case TRUE:
25162 case TYPE:
25163 case UI:
25164 case UNDER:
25165 case USING:
25166 case WHILE:
25167 case YES:
25168 case SHOW:
25169 case A:
25170 case UPDATE:
25171 case VARCHAR:
25172 case VARCHAR2:
25173 case DOUBLE:
25174 case DEC:
25175 case PRECISION:
25176 case INT:
25177 case NUMERIC:
25178 case SIGNTYPE:
25179 case NCHAR:
25180 case NVARCHAR2:
25181 case STRING:
25182 case UROWID:
25183 case VARRAY:
25184 case VARYING:
25185 case BFILE:
25186 case BLOB:
25187 case CLOB:
25188 case NCLOB:
25189 case YEAR:
25190 case LOCAL:
25191 case WITH:
25192 case ZONE:
25193 case CHARACTER:
25194 case AFTER:
25195 case BEFORE:
25196 case OLD:
25197 case PARENT:
25198 case ANALYZE:
25199 case ASSOCIATE:
25200 case AUDIT:
25201 case COMPOUND:
25202 case DATABASE:
25203 case CALL:
25204 case DDL:
25205 case DISASSOCIATE:
25206 case EACH:
25207 case FOLLOWS:
25208 case LOGOFF:
25209 case LOGON:
25210 case NESTED:
25211 case NOAUDIT:
25212 case SCHEMA:
25213 case SERVERERROR:
25214 case SHUTDOWN:
25215 case STARTUP:
25216 case STATEMENT:
25217 case STATISTICS:
25218 case SUSPEND:
25219 case TRUNCATE:
25220 case WRAPPED:
25221 case LIBRARY:
25222 case NAME:
25223 case STRUCT:
25224 case CONTEXT:
25225 case PARAMETERS:
25226 case LENGTH:
25227 case TDO:
25228 case MAXLEN:
25229 case CHARSETID:
25230 case CHARSETFORM:
25231 case ACCEPT:
25232 case ACCESSIBLE:
25233 case COPY:
25234 case DEFINE:
25235 case DISCONNECT:
25236 case HOST:
25237 case PRINT:
25238 case QUIT:
25239 case REMARK:
25240 case UNDEFINE:
25241 case VARIABLE:
25242 case WHENEVER:
25243 case ATTACH:
25244 case CAST:
25245 case TREAT:
25246 case TRIM:
25247 case LEFT:
25248 case RIGHT:
25249 case BOTH:
25250 case EMPTY:
25251 case MULTISET:
25252 case SUBMULTISET:
25253 case LEADING:
25254 case TRAILING:
25255 case CHAR_CS:
25256 case NCHAR_CS:
25257 case DBTIMEZONE:
25258 case SESSIONTIMEZONE:
25259 case AUTHENTICATED:
25260 case LINK:
25261 case SHARED:
25262 case DIRECTORY:
25263 case USER:
25264 case IDENTIFIER:
25265 case QUOTED_LITERAL:
25266 case SQLDATA_CLASS:
25267 case CUSTOMDATUM_CLASS:
25268 case ORADATA_CLASS:
25269 case JAVA_INTERFACE_CLASS:
25270 ;
25271 break;
25272 default:
25273 jj_la1[358] = jj_gen;
25274 break label_76;
25275 }
25276 if (jj_2_69(2)) {
25277 TypeMethod();
25278 } else {
25279 switch (jj_nt.kind) {
25280 case REPLACE:
25281 case DEFINER:
25282 case CURRENT_USER:
25283 case SERIALLY_REUSABLE:
25284 case RESTRICT_REFERENCES:
25285 case EXCEPTION_INIT:
25286 case AUTONOMOUS_TRANSACTION:
25287 case LANGUAGE:
25288 case INLINE:
25289 case ADD:
25290 case AGGREGATE:
25291 case ALL:
25292 case ALTER:
25293 case AND:
25294 case ANY:
25295 case ARRAY:
25296 case AS:
25297 case ASC:
25298 case AT:
25299 case ATTRIBUTE:
25300 case AUTHID:
25301 case AVG:
25302 case BETWEEN:
25303 case BINARY_INTEGER:
25304 case BODY:
25305 case BOOLEAN:
25306 case BULK:
25307 case BY:
25308 case BYTE:
25309 case CASCADE:
25310 case CASE:
25311 case CHAR:
25312 case CHAR_BASE:
25313 case CHECK:
25314 case CLOSE:
25315 case CLUSTER:
25316 case COALESCE:
25317 case COLLECT:
25318 case COLUMN:
25319 case COMMENT:
25320 case COMMIT:
25321 case COMPRESS:
25322 case CONNECT:
25323 case CONSTANT:
25324 case CONSTRUCTOR:
25325 case CONTINUE:
25326 case CONVERT:
25327 case CREATE:
25328 case CURRENT:
25329 case CURRVAL:
25330 case CURSOR:
25331 case DATA:
25332 case DATE:
25333 case DAY:
25334 case DECLARE:
25335 case DECIMAL:
25336 case _DEFAULT:
25337 case DELETE:
25338 case DESC:
25339 case DISABLE:
25340 case DISTINCT:
25341 case DO:
25342 case DROP:
25343 case EDITIONABLE:
25344 case ELEMENT:
25345 case ELSE:
25346 case ELSIF:
25347 case ENABLE:
25348 case ESCAPE:
25349 case EXCEPT:
25350 case EXCEPTION:
25351 case EXCEPTIONS:
25352 case EXCLUSIVE:
25353 case EXECUTE:
25354 case EXISTS:
25355 case EXIT:
25356 case EXTERNAL:
25357 case EXTENDS:
25358 case EXTRACT:
25359 case FALSE:
25360 case FETCH:
25361 case FINAL:
25362 case FLOAT:
25363 case FOR:
25364 case FORALL:
25365 case FORCE:
25366 case FROM:
25367 case FUNCTION:
25368 case GLOBAL:
25369 case GOTO:
25370 case GROUP:
25371 case HASH:
25372 case HAVING:
25373 case HEAP:
25374 case HOUR:
25375 case IF:
25376 case IMMEDIATE:
25377 case IN:
25378 case INDEX:
25379 case INDICES:
25380 case INDEXTYPE:
25381 case INDICATOR:
25382 case INSERT:
25383 case INSTANTIABLE:
25384 case INTEGER:
25385 case INTERFACE:
25386 case INTERSECT:
25387 case INTERVAL:
25388 case INTO:
25389 case INVALIDATE:
25390 case IS:
25391 case ISOLATION:
25392 case JAVA:
25393 case LEVEL:
25394 case LIKE:
25395 case LIMIT:
25396 case LIMITED:
25397 case LOCK:
25398 case LONG:
25399 case LOOP:
25400 case MAP:
25401 case MAX:
25402 case MEMBER:
25403 case MERGE:
25404 case MIN:
25405 case MINUS:
25406 case MINUTE:
25407 case MLSLABEL:
25408 case MODIFY:
25409 case MOD:
25410 case MODE:
25411 case MONTH:
25412 case NATURAL:
25413 case NATURALN:
25414 case NEW:
25415 case NEXTVAL:
25416 case NO:
25417 case NOCOPY:
25418 case NONEDITIONABLE:
25419 case NOT:
25420 case NOWAIT:
25421 case NULL:
25422 case NULLIF:
25423 case NUMBER:
25424 case BFILE_BASE:
25425 case BLOB_BASE:
25426 case CLOB_BASE:
25427 case DATE_BASE:
25428 case NUMBER_BASE:
25429 case OBJECT:
25430 case OCIROWID:
25431 case OF:
25432 case OID:
25433 case ON:
25434 case OPAQUE:
25435 case OPEN:
25436 case OPERATOR:
25437 case OPTION:
25438 case OR:
25439 case ORDER:
25440 case ORGANIZATION:
25441 case OTHERS:
25442 case OUT:
25443 case OVERRIDING:
25444 case PACKAGE:
25445 case PARTITION:
25446 case PCTFREE:
25447 case PLS_INTEGER:
25448 case POSITIVE:
25449 case POSITIVEN:
25450 case PRESERVE:
25451 case PRIOR:
25452 case PROMPT:
25453 case PRIVATE:
25454 case PROCEDURE:
25455 case PUBLIC:
25456 case RAISE:
25457 case RANGE:
25458 case RAW:
25459 case REAL:
25460 case RECORD:
25461 case REF:
25462 case RELEASE:
25463 case RELIES_ON:
25464 case RENAME:
25465 case RESULT:
25466 case RETURN:
25467 case RETURNING:
25468 case REVERSE:
25469 case ROLLBACK:
25470 case ROW:
25471 case ROWS:
25472 case ROWID:
25473 case ROWNUM:
25474 case ROWTYPE:
25475 case SAVE:
25476 case SAVEPOINT:
25477 case SECOND:
25478 case SELECT:
25479 case SELF:
25480 case SEPARATE:
25481 case SET:
25482 case SHARE:
25483 case SMALLINT:
25484 case SPACE:
25485 case SQL:
25486 case SQLCODE:
25487 case SQLERRM:
25488 case START:
25489 case STATIC:
25490 case STDDEV:
25491 case SUBTYPE:
25492 case SUBSTITUTABLE:
25493 case SUCCESSFUL:
25494 case SUM:
25495 case SYNONYM:
25496 case SYSDATE:
25497 case SYS_REFCURSOR:
25498 case TABLE:
25499 case TEMPORARY:
25500 case THEN:
25501 case TIME:
25502 case TIMESTAMP:
25503 case TIMEZONE_REGION:
25504 case TIMEZONE_ABBR:
25505 case TIMEZONE_MINUTE:
25506 case TIMEZONE_HOUR:
25507 case TO:
25508 case TRANSACTION:
25509 case TRIGGER:
25510 case TRUE:
25511 case TYPE:
25512 case UI:
25513 case UNDER:
25514 case USING:
25515 case WHILE:
25516 case YES:
25517 case SHOW:
25518 case A:
25519 case UPDATE:
25520 case VARCHAR:
25521 case VARCHAR2:
25522 case DOUBLE:
25523 case DEC:
25524 case PRECISION:
25525 case INT:
25526 case NUMERIC:
25527 case SIGNTYPE:
25528 case NCHAR:
25529 case NVARCHAR2:
25530 case STRING:
25531 case UROWID:
25532 case VARRAY:
25533 case VARYING:
25534 case BFILE:
25535 case BLOB:
25536 case CLOB:
25537 case NCLOB:
25538 case YEAR:
25539 case LOCAL:
25540 case WITH:
25541 case ZONE:
25542 case CHARACTER:
25543 case AFTER:
25544 case BEFORE:
25545 case OLD:
25546 case PARENT:
25547 case ANALYZE:
25548 case ASSOCIATE:
25549 case AUDIT:
25550 case COMPOUND:
25551 case DATABASE:
25552 case CALL:
25553 case DDL:
25554 case DISASSOCIATE:
25555 case EACH:
25556 case FOLLOWS:
25557 case LOGOFF:
25558 case LOGON:
25559 case NESTED:
25560 case NOAUDIT:
25561 case SCHEMA:
25562 case SERVERERROR:
25563 case SHUTDOWN:
25564 case STARTUP:
25565 case STATEMENT:
25566 case STATISTICS:
25567 case SUSPEND:
25568 case TRUNCATE:
25569 case WRAPPED:
25570 case LIBRARY:
25571 case NAME:
25572 case STRUCT:
25573 case CONTEXT:
25574 case PARAMETERS:
25575 case LENGTH:
25576 case TDO:
25577 case MAXLEN:
25578 case CHARSETID:
25579 case CHARSETFORM:
25580 case ACCEPT:
25581 case ACCESSIBLE:
25582 case COPY:
25583 case DEFINE:
25584 case DISCONNECT:
25585 case HOST:
25586 case PRINT:
25587 case QUIT:
25588 case REMARK:
25589 case UNDEFINE:
25590 case VARIABLE:
25591 case WHENEVER:
25592 case ATTACH:
25593 case CAST:
25594 case TREAT:
25595 case TRIM:
25596 case LEFT:
25597 case RIGHT:
25598 case BOTH:
25599 case EMPTY:
25600 case MULTISET:
25601 case SUBMULTISET:
25602 case LEADING:
25603 case TRAILING:
25604 case CHAR_CS:
25605 case NCHAR_CS:
25606 case DBTIMEZONE:
25607 case SESSIONTIMEZONE:
25608 case AUTHENTICATED:
25609 case LINK:
25610 case SHARED:
25611 case DIRECTORY:
25612 case USER:
25613 case IDENTIFIER:
25614 case QUOTED_LITERAL:
25615 case SQLDATA_CLASS:
25616 case CUSTOMDATUM_CLASS:
25617 case ORADATA_CLASS:
25618 case JAVA_INTERFACE_CLASS:
25619 AttributeDeclaration();
25620 break;
25621 case PRAGMA:
25622 PragmaClause();
25623 break;
25624 default:
25625 jj_la1[359] = jj_gen;
25626 jj_consume_token(-1);
25627 throw new ParseException();
25628 }
25629 }
25630 }
25631 label_77:
25632 while (true) {
25633 switch (jj_nt.kind) {
25634 case 6:
25635 ;
25636 break;
25637 default:
25638 jj_la1[360] = jj_gen;
25639 break label_77;
25640 }
25641 jj_consume_token(6);
25642 switch (jj_nt.kind) {
25643 case CONSTRUCTOR:
25644 case FINAL:
25645 case INSTANTIABLE:
25646 case MAP:
25647 case MEMBER:
25648 case NOT:
25649 case ORDER:
25650 case OVERRIDING:
25651 case STATIC:
25652 TypeMethod();
25653 break;
25654 default:
25655 jj_la1[361] = jj_gen;
25656 if (jj_2_70(2)) {
25657 AttributeDeclaration();
25658 } else {
25659 switch (jj_nt.kind) {
25660 case PRAGMA:
25661 PragmaClause();
25662 break;
25663 default:
25664 jj_la1[362] = jj_gen;
25665 jj_consume_token(-1);
25666 throw new ParseException();
25667 }
25668 }
25669 }
25670 }
25671 jj_consume_token(7);
25672 break;
25673 default:
25674 jj_la1[363] = jj_gen;
25675 ;
25676 }
25677 label_78:
25678 while (true) {
25679 switch (jj_nt.kind) {
25680 case FINAL:
25681 case INSTANTIABLE:
25682 case NOT:
25683 case NULL:
25684 ;
25685 break;
25686 default:
25687 jj_la1[364] = jj_gen;
25688 break label_78;
25689 }
25690 switch (jj_nt.kind) {
25691 case NOT:
25692 jj_consume_token(NOT);
25693 break;
25694 default:
25695 jj_la1[365] = jj_gen;
25696 ;
25697 }
25698 switch (jj_nt.kind) {
25699 case FINAL:
25700 jj_consume_token(FINAL);
25701 break;
25702 case INSTANTIABLE:
25703 jj_consume_token(INSTANTIABLE);
25704 break;
25705 case NULL:
25706 jj_consume_token(NULL);
25707 break;
25708 default:
25709 jj_la1[366] = jj_gen;
25710 jj_consume_token(-1);
25711 throw new ParseException();
25712 }
25713 }
25714 label_79:
25715 while (true) {
25716 switch (jj_nt.kind) {
25717 case ALTER:
25718 ;
25719 break;
25720 default:
25721 jj_la1[367] = jj_gen;
25722 break label_79;
25723 }
25724 AlterTypeSpec();
25725 }
25726 switch (jj_nt.kind) {
25727 case 1:
25728 case 4:
25729 switch (jj_nt.kind) {
25730 case 4:
25731 jj_consume_token(4);
25732 break;
25733 case 1:
25734 jj_consume_token(1);
25735 break;
25736 default:
25737 jj_la1[368] = jj_gen;
25738 jj_consume_token(-1);
25739 throw new ParseException();
25740 }
25741 label_80:
25742 while (true) {
25743 switch (jj_nt.kind) {
25744 case ALTER:
25745 ;
25746 break;
25747 default:
25748 jj_la1[369] = jj_gen;
25749 break label_80;
25750 }
25751 AlterTypeSpec();
25752 switch (jj_nt.kind) {
25753 case 1:
25754 jj_consume_token(1);
25755 break;
25756 case 4:
25757 jj_consume_token(4);
25758 break;
25759 default:
25760 jj_la1[370] = jj_gen;
25761 jj_consume_token(-1);
25762 throw new ParseException();
25763 }
25764 }
25765 break;
25766 default:
25767 jj_la1[371] = jj_gen;
25768 ;
25769 }
25770 jjtree.closeNodeScope(jjtn000, true);
25771 jjtc000 = false;
25772 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
25773 } catch (Throwable jjte000) {
25774 if (jjtc000) {
25775 jjtree.clearNodeScope(jjtn000);
25776 jjtc000 = false;
25777 } else {
25778 jjtree.popNode();
25779 }
25780 if (jjte000 instanceof RuntimeException) {
25781 {if (true) throw (RuntimeException)jjte000;}
25782 }
25783 if (jjte000 instanceof ParseException) {
25784 {if (true) throw (ParseException)jjte000;}
25785 }
25786 {if (true) throw (Error)jjte000;}
25787 } finally {
25788 if (jjtc000) {
25789 jjtree.closeNodeScope(jjtn000, true);
25790 }
25791 }
25792 throw new Error("Missing return statement in function");
25793 }
25794
25795 final public ASTAlterTypeSpec AlterTypeSpec() throws ParseException {
25796
25797 ASTAlterTypeSpec jjtn000 = new ASTAlterTypeSpec(this, JJTALTERTYPESPEC);
25798 boolean jjtc000 = true;
25799 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
25800 try {
25801 jj_consume_token(ALTER);
25802 jj_consume_token(TYPE);
25803 simpleNode = QualifiedName();
25804 label_81:
25805 while (true) {
25806 switch (jj_nt.kind) {
25807 case 6:
25808 case ADD:
25809 case DROP:
25810 case MODIFY:
25811 ;
25812 break;
25813 default:
25814 jj_la1[372] = jj_gen;
25815 break label_81;
25816 }
25817 switch (jj_nt.kind) {
25818 case 6:
25819 case ADD:
25820 case MODIFY:
25821 switch (jj_nt.kind) {
25822 case 6:
25823 jj_consume_token(6);
25824 break;
25825 default:
25826 jj_la1[373] = jj_gen;
25827 ;
25828 }
25829 switch (jj_nt.kind) {
25830 case ADD:
25831 jj_consume_token(ADD);
25832 break;
25833 case MODIFY:
25834 jj_consume_token(MODIFY);
25835 break;
25836 default:
25837 jj_la1[374] = jj_gen;
25838 jj_consume_token(-1);
25839 throw new ParseException();
25840 }
25841 label_82:
25842 while (true) {
25843 switch (jj_nt.kind) {
25844 case CONSTRUCTOR:
25845 case FINAL:
25846 case INSTANTIABLE:
25847 case MAP:
25848 case MEMBER:
25849 case NOT:
25850 case ORDER:
25851 case OVERRIDING:
25852 case STATIC:
25853 TypeMethod();
25854 break;
25855 case ATTRIBUTE:
25856 jj_consume_token(ATTRIBUTE);
25857 label_83:
25858 while (true) {
25859 switch (jj_nt.kind) {
25860 case 5:
25861 ;
25862 break;
25863 default:
25864 jj_la1[375] = jj_gen;
25865 break label_83;
25866 }
25867 jj_consume_token(5);
25868 }
25869 AttributeDeclaration();
25870 label_84:
25871 while (true) {
25872 switch (jj_nt.kind) {
25873 case 6:
25874 ;
25875 break;
25876 default:
25877 jj_la1[376] = jj_gen;
25878 break label_84;
25879 }
25880 jj_consume_token(6);
25881 AttributeDeclaration();
25882 }
25883 label_85:
25884 while (true) {
25885 switch (jj_nt.kind) {
25886 case 7:
25887 ;
25888 break;
25889 default:
25890 jj_la1[377] = jj_gen;
25891 break label_85;
25892 }
25893 jj_consume_token(7);
25894 }
25895 break;
25896 case LIMIT:
25897 jj_consume_token(LIMIT);
25898 NumericLiteral();
25899 break;
25900 case ELEMENT:
25901 jj_consume_token(ELEMENT);
25902 jj_consume_token(TYPE);
25903 Datatype();
25904 break;
25905 default:
25906 jj_la1[378] = jj_gen;
25907 jj_consume_token(-1);
25908 throw new ParseException();
25909 }
25910 switch (jj_nt.kind) {
25911 case ATTRIBUTE:
25912 case CONSTRUCTOR:
25913 case ELEMENT:
25914 case FINAL:
25915 case INSTANTIABLE:
25916 case LIMIT:
25917 case MAP:
25918 case MEMBER:
25919 case NOT:
25920 case ORDER:
25921 case OVERRIDING:
25922 case STATIC:
25923 ;
25924 break;
25925 default:
25926 jj_la1[379] = jj_gen;
25927 break label_82;
25928 }
25929 }
25930 break;
25931 case DROP:
25932 jj_consume_token(DROP);
25933 label_86:
25934 while (true) {
25935 switch (jj_nt.kind) {
25936 case ATTRIBUTE:
25937 jj_consume_token(ATTRIBUTE);
25938 label_87:
25939 while (true) {
25940 switch (jj_nt.kind) {
25941 case 5:
25942 ;
25943 break;
25944 default:
25945 jj_la1[380] = jj_gen;
25946 break label_87;
25947 }
25948 jj_consume_token(5);
25949 }
25950 Attribute();
25951 label_88:
25952 while (true) {
25953 switch (jj_nt.kind) {
25954 case 6:
25955 ;
25956 break;
25957 default:
25958 jj_la1[381] = jj_gen;
25959 break label_88;
25960 }
25961 jj_consume_token(6);
25962 Attribute();
25963 }
25964 label_89:
25965 while (true) {
25966 switch (jj_nt.kind) {
25967 case 7:
25968 ;
25969 break;
25970 default:
25971 jj_la1[382] = jj_gen;
25972 break label_89;
25973 }
25974 jj_consume_token(7);
25975 }
25976 break;
25977 case CONSTRUCTOR:
25978 case FINAL:
25979 case INSTANTIABLE:
25980 case MAP:
25981 case MEMBER:
25982 case NOT:
25983 case ORDER:
25984 case OVERRIDING:
25985 case STATIC:
25986 TypeMethod();
25987 break;
25988 default:
25989 jj_la1[383] = jj_gen;
25990 jj_consume_token(-1);
25991 throw new ParseException();
25992 }
25993 switch (jj_nt.kind) {
25994 case ATTRIBUTE:
25995 case CONSTRUCTOR:
25996 case FINAL:
25997 case INSTANTIABLE:
25998 case MAP:
25999 case MEMBER:
26000 case NOT:
26001 case ORDER:
26002 case OVERRIDING:
26003 case STATIC:
26004 ;
26005 break;
26006 default:
26007 jj_la1[384] = jj_gen;
26008 break label_86;
26009 }
26010 }
26011 break;
26012 default:
26013 jj_la1[385] = jj_gen;
26014 jj_consume_token(-1);
26015 throw new ParseException();
26016 }
26017 }
26018 switch (jj_nt.kind) {
26019 case REPLACE:
26020 jj_consume_token(REPLACE);
26021 label_90:
26022 while (true) {
26023 if (jj_2_71(2)) {
26024 ;
26025 } else {
26026 break label_90;
26027 }
26028 switch (jj_nt.kind) {
26029 case AUTHID:
26030 jj_consume_token(AUTHID);
26031 switch (jj_nt.kind) {
26032 case CURRENT_USER:
26033 jj_consume_token(CURRENT_USER);
26034 break;
26035 case DEFINER:
26036 jj_consume_token(DEFINER);
26037 break;
26038 default:
26039 jj_la1[386] = jj_gen;
26040 jj_consume_token(-1);
26041 throw new ParseException();
26042 }
26043 break;
26044 case ACCESSIBLE:
26045 AccessibleByClause();
26046 break;
26047 default:
26048 jj_la1[387] = jj_gen;
26049 jj_consume_token(-1);
26050 throw new ParseException();
26051 }
26052 }
26053 switch (jj_nt.kind) {
26054 case IS:
26055 jj_consume_token(IS);
26056 break;
26057 case AS:
26058 jj_consume_token(AS);
26059 break;
26060 default:
26061 jj_la1[388] = jj_gen;
26062 jj_consume_token(-1);
26063 throw new ParseException();
26064 }
26065 jj_consume_token(OBJECT);
26066 jj_consume_token(5);
26067 if (jj_2_72(2)) {
26068 TypeMethod();
26069 } else {
26070 switch (jj_nt.kind) {
26071 case REPLACE:
26072 case DEFINER:
26073 case CURRENT_USER:
26074 case SERIALLY_REUSABLE:
26075 case RESTRICT_REFERENCES:
26076 case EXCEPTION_INIT:
26077 case AUTONOMOUS_TRANSACTION:
26078 case LANGUAGE:
26079 case INLINE:
26080 case ADD:
26081 case AGGREGATE:
26082 case ALL:
26083 case ALTER:
26084 case AND:
26085 case ANY:
26086 case ARRAY:
26087 case AS:
26088 case ASC:
26089 case AT:
26090 case ATTRIBUTE:
26091 case AUTHID:
26092 case AVG:
26093 case BETWEEN:
26094 case BINARY_INTEGER:
26095 case BODY:
26096 case BOOLEAN:
26097 case BULK:
26098 case BY:
26099 case BYTE:
26100 case CASCADE:
26101 case CASE:
26102 case CHAR:
26103 case CHAR_BASE:
26104 case CHECK:
26105 case CLOSE:
26106 case CLUSTER:
26107 case COALESCE:
26108 case COLLECT:
26109 case COLUMN:
26110 case COMMENT:
26111 case COMMIT:
26112 case COMPRESS:
26113 case CONNECT:
26114 case CONSTANT:
26115 case CONSTRUCTOR:
26116 case CONTINUE:
26117 case CONVERT:
26118 case CREATE:
26119 case CURRENT:
26120 case CURRVAL:
26121 case CURSOR:
26122 case DATA:
26123 case DATE:
26124 case DAY:
26125 case DECLARE:
26126 case DECIMAL:
26127 case _DEFAULT:
26128 case DELETE:
26129 case DESC:
26130 case DISABLE:
26131 case DISTINCT:
26132 case DO:
26133 case DROP:
26134 case EDITIONABLE:
26135 case ELEMENT:
26136 case ELSE:
26137 case ELSIF:
26138 case ENABLE:
26139 case ESCAPE:
26140 case EXCEPT:
26141 case EXCEPTION:
26142 case EXCEPTIONS:
26143 case EXCLUSIVE:
26144 case EXECUTE:
26145 case EXISTS:
26146 case EXIT:
26147 case EXTERNAL:
26148 case EXTENDS:
26149 case EXTRACT:
26150 case FALSE:
26151 case FETCH:
26152 case FINAL:
26153 case FLOAT:
26154 case FOR:
26155 case FORALL:
26156 case FORCE:
26157 case FROM:
26158 case FUNCTION:
26159 case GLOBAL:
26160 case GOTO:
26161 case GROUP:
26162 case HASH:
26163 case HAVING:
26164 case HEAP:
26165 case HOUR:
26166 case IF:
26167 case IMMEDIATE:
26168 case IN:
26169 case INDEX:
26170 case INDICES:
26171 case INDEXTYPE:
26172 case INDICATOR:
26173 case INSERT:
26174 case INSTANTIABLE:
26175 case INTEGER:
26176 case INTERFACE:
26177 case INTERSECT:
26178 case INTERVAL:
26179 case INTO:
26180 case INVALIDATE:
26181 case IS:
26182 case ISOLATION:
26183 case JAVA:
26184 case LEVEL:
26185 case LIKE:
26186 case LIMIT:
26187 case LIMITED:
26188 case LOCK:
26189 case LONG:
26190 case LOOP:
26191 case MAP:
26192 case MAX:
26193 case MEMBER:
26194 case MERGE:
26195 case MIN:
26196 case MINUS:
26197 case MINUTE:
26198 case MLSLABEL:
26199 case MODIFY:
26200 case MOD:
26201 case MODE:
26202 case MONTH:
26203 case NATURAL:
26204 case NATURALN:
26205 case NEW:
26206 case NEXTVAL:
26207 case NO:
26208 case NOCOPY:
26209 case NONEDITIONABLE:
26210 case NOT:
26211 case NOWAIT:
26212 case NULL:
26213 case NULLIF:
26214 case NUMBER:
26215 case BFILE_BASE:
26216 case BLOB_BASE:
26217 case CLOB_BASE:
26218 case DATE_BASE:
26219 case NUMBER_BASE:
26220 case OBJECT:
26221 case OCIROWID:
26222 case OF:
26223 case OID:
26224 case ON:
26225 case OPAQUE:
26226 case OPEN:
26227 case OPERATOR:
26228 case OPTION:
26229 case OR:
26230 case ORDER:
26231 case ORGANIZATION:
26232 case OTHERS:
26233 case OUT:
26234 case OVERRIDING:
26235 case PACKAGE:
26236 case PARTITION:
26237 case PCTFREE:
26238 case PLS_INTEGER:
26239 case POSITIVE:
26240 case POSITIVEN:
26241 case PRESERVE:
26242 case PRIOR:
26243 case PROMPT:
26244 case PRIVATE:
26245 case PROCEDURE:
26246 case PUBLIC:
26247 case RAISE:
26248 case RANGE:
26249 case RAW:
26250 case REAL:
26251 case RECORD:
26252 case REF:
26253 case RELEASE:
26254 case RELIES_ON:
26255 case RENAME:
26256 case RESULT:
26257 case RETURN:
26258 case RETURNING:
26259 case REVERSE:
26260 case ROLLBACK:
26261 case ROW:
26262 case ROWS:
26263 case ROWID:
26264 case ROWNUM:
26265 case ROWTYPE:
26266 case SAVE:
26267 case SAVEPOINT:
26268 case SECOND:
26269 case SELECT:
26270 case SELF:
26271 case SEPARATE:
26272 case SET:
26273 case SHARE:
26274 case SMALLINT:
26275 case SPACE:
26276 case SQL:
26277 case SQLCODE:
26278 case SQLERRM:
26279 case START:
26280 case STATIC:
26281 case STDDEV:
26282 case SUBTYPE:
26283 case SUBSTITUTABLE:
26284 case SUCCESSFUL:
26285 case SUM:
26286 case SYNONYM:
26287 case SYSDATE:
26288 case SYS_REFCURSOR:
26289 case TABLE:
26290 case TEMPORARY:
26291 case THEN:
26292 case TIME:
26293 case TIMESTAMP:
26294 case TIMEZONE_REGION:
26295 case TIMEZONE_ABBR:
26296 case TIMEZONE_MINUTE:
26297 case TIMEZONE_HOUR:
26298 case TO:
26299 case TRANSACTION:
26300 case TRIGGER:
26301 case TRUE:
26302 case TYPE:
26303 case UI:
26304 case UNDER:
26305 case USING:
26306 case WHILE:
26307 case YES:
26308 case SHOW:
26309 case A:
26310 case UPDATE:
26311 case VARCHAR:
26312 case VARCHAR2:
26313 case DOUBLE:
26314 case DEC:
26315 case PRECISION:
26316 case INT:
26317 case NUMERIC:
26318 case SIGNTYPE:
26319 case NCHAR:
26320 case NVARCHAR2:
26321 case STRING:
26322 case UROWID:
26323 case VARRAY:
26324 case VARYING:
26325 case BFILE:
26326 case BLOB:
26327 case CLOB:
26328 case NCLOB:
26329 case YEAR:
26330 case LOCAL:
26331 case WITH:
26332 case ZONE:
26333 case CHARACTER:
26334 case AFTER:
26335 case BEFORE:
26336 case OLD:
26337 case PARENT:
26338 case ANALYZE:
26339 case ASSOCIATE:
26340 case AUDIT:
26341 case COMPOUND:
26342 case DATABASE:
26343 case CALL:
26344 case DDL:
26345 case DISASSOCIATE:
26346 case EACH:
26347 case FOLLOWS:
26348 case LOGOFF:
26349 case LOGON:
26350 case NESTED:
26351 case NOAUDIT:
26352 case SCHEMA:
26353 case SERVERERROR:
26354 case SHUTDOWN:
26355 case STARTUP:
26356 case STATEMENT:
26357 case STATISTICS:
26358 case SUSPEND:
26359 case TRUNCATE:
26360 case WRAPPED:
26361 case LIBRARY:
26362 case NAME:
26363 case STRUCT:
26364 case CONTEXT:
26365 case PARAMETERS:
26366 case LENGTH:
26367 case TDO:
26368 case MAXLEN:
26369 case CHARSETID:
26370 case CHARSETFORM:
26371 case ACCEPT:
26372 case ACCESSIBLE:
26373 case COPY:
26374 case DEFINE:
26375 case DISCONNECT:
26376 case HOST:
26377 case PRINT:
26378 case QUIT:
26379 case REMARK:
26380 case UNDEFINE:
26381 case VARIABLE:
26382 case WHENEVER:
26383 case ATTACH:
26384 case CAST:
26385 case TREAT:
26386 case TRIM:
26387 case LEFT:
26388 case RIGHT:
26389 case BOTH:
26390 case EMPTY:
26391 case MULTISET:
26392 case SUBMULTISET:
26393 case LEADING:
26394 case TRAILING:
26395 case CHAR_CS:
26396 case NCHAR_CS:
26397 case DBTIMEZONE:
26398 case SESSIONTIMEZONE:
26399 case AUTHENTICATED:
26400 case LINK:
26401 case SHARED:
26402 case DIRECTORY:
26403 case USER:
26404 case IDENTIFIER:
26405 case QUOTED_LITERAL:
26406 case SQLDATA_CLASS:
26407 case CUSTOMDATUM_CLASS:
26408 case ORADATA_CLASS:
26409 case JAVA_INTERFACE_CLASS:
26410 AttributeDeclaration();
26411 break;
26412 default:
26413 jj_la1[389] = jj_gen;
26414 jj_consume_token(-1);
26415 throw new ParseException();
26416 }
26417 }
26418 label_91:
26419 while (true) {
26420 switch (jj_nt.kind) {
26421 case 6:
26422 ;
26423 break;
26424 default:
26425 jj_la1[390] = jj_gen;
26426 break label_91;
26427 }
26428 jj_consume_token(6);
26429 if (jj_2_73(2)) {
26430 TypeMethod();
26431 } else {
26432 switch (jj_nt.kind) {
26433 case REPLACE:
26434 case DEFINER:
26435 case CURRENT_USER:
26436 case SERIALLY_REUSABLE:
26437 case RESTRICT_REFERENCES:
26438 case EXCEPTION_INIT:
26439 case AUTONOMOUS_TRANSACTION:
26440 case LANGUAGE:
26441 case INLINE:
26442 case ADD:
26443 case AGGREGATE:
26444 case ALL:
26445 case ALTER:
26446 case AND:
26447 case ANY:
26448 case ARRAY:
26449 case AS:
26450 case ASC:
26451 case AT:
26452 case ATTRIBUTE:
26453 case AUTHID:
26454 case AVG:
26455 case BETWEEN:
26456 case BINARY_INTEGER:
26457 case BODY:
26458 case BOOLEAN:
26459 case BULK:
26460 case BY:
26461 case BYTE:
26462 case CASCADE:
26463 case CASE:
26464 case CHAR:
26465 case CHAR_BASE:
26466 case CHECK:
26467 case CLOSE:
26468 case CLUSTER:
26469 case COALESCE:
26470 case COLLECT:
26471 case COLUMN:
26472 case COMMENT:
26473 case COMMIT:
26474 case COMPRESS:
26475 case CONNECT:
26476 case CONSTANT:
26477 case CONSTRUCTOR:
26478 case CONTINUE:
26479 case CONVERT:
26480 case CREATE:
26481 case CURRENT:
26482 case CURRVAL:
26483 case CURSOR:
26484 case DATA:
26485 case DATE:
26486 case DAY:
26487 case DECLARE:
26488 case DECIMAL:
26489 case _DEFAULT:
26490 case DELETE:
26491 case DESC:
26492 case DISABLE:
26493 case DISTINCT:
26494 case DO:
26495 case DROP:
26496 case EDITIONABLE:
26497 case ELEMENT:
26498 case ELSE:
26499 case ELSIF:
26500 case ENABLE:
26501 case ESCAPE:
26502 case EXCEPT:
26503 case EXCEPTION:
26504 case EXCEPTIONS:
26505 case EXCLUSIVE:
26506 case EXECUTE:
26507 case EXISTS:
26508 case EXIT:
26509 case EXTERNAL:
26510 case EXTENDS:
26511 case EXTRACT:
26512 case FALSE:
26513 case FETCH:
26514 case FINAL:
26515 case FLOAT:
26516 case FOR:
26517 case FORALL:
26518 case FORCE:
26519 case FROM:
26520 case FUNCTION:
26521 case GLOBAL:
26522 case GOTO:
26523 case GROUP:
26524 case HASH:
26525 case HAVING:
26526 case HEAP:
26527 case HOUR:
26528 case IF:
26529 case IMMEDIATE:
26530 case IN:
26531 case INDEX:
26532 case INDICES:
26533 case INDEXTYPE:
26534 case INDICATOR:
26535 case INSERT:
26536 case INSTANTIABLE:
26537 case INTEGER:
26538 case INTERFACE:
26539 case INTERSECT:
26540 case INTERVAL:
26541 case INTO:
26542 case INVALIDATE:
26543 case IS:
26544 case ISOLATION:
26545 case JAVA:
26546 case LEVEL:
26547 case LIKE:
26548 case LIMIT:
26549 case LIMITED:
26550 case LOCK:
26551 case LONG:
26552 case LOOP:
26553 case MAP:
26554 case MAX:
26555 case MEMBER:
26556 case MERGE:
26557 case MIN:
26558 case MINUS:
26559 case MINUTE:
26560 case MLSLABEL:
26561 case MODIFY:
26562 case MOD:
26563 case MODE:
26564 case MONTH:
26565 case NATURAL:
26566 case NATURALN:
26567 case NEW:
26568 case NEXTVAL:
26569 case NO:
26570 case NOCOPY:
26571 case NONEDITIONABLE:
26572 case NOT:
26573 case NOWAIT:
26574 case NULL:
26575 case NULLIF:
26576 case NUMBER:
26577 case BFILE_BASE:
26578 case BLOB_BASE:
26579 case CLOB_BASE:
26580 case DATE_BASE:
26581 case NUMBER_BASE:
26582 case OBJECT:
26583 case OCIROWID:
26584 case OF:
26585 case OID:
26586 case ON:
26587 case OPAQUE:
26588 case OPEN:
26589 case OPERATOR:
26590 case OPTION:
26591 case OR:
26592 case ORDER:
26593 case ORGANIZATION:
26594 case OTHERS:
26595 case OUT:
26596 case OVERRIDING:
26597 case PACKAGE:
26598 case PARTITION:
26599 case PCTFREE:
26600 case PLS_INTEGER:
26601 case POSITIVE:
26602 case POSITIVEN:
26603 case PRESERVE:
26604 case PRIOR:
26605 case PROMPT:
26606 case PRIVATE:
26607 case PROCEDURE:
26608 case PUBLIC:
26609 case RAISE:
26610 case RANGE:
26611 case RAW:
26612 case REAL:
26613 case RECORD:
26614 case REF:
26615 case RELEASE:
26616 case RELIES_ON:
26617 case RENAME:
26618 case RESULT:
26619 case RETURN:
26620 case RETURNING:
26621 case REVERSE:
26622 case ROLLBACK:
26623 case ROW:
26624 case ROWS:
26625 case ROWID:
26626 case ROWNUM:
26627 case ROWTYPE:
26628 case SAVE:
26629 case SAVEPOINT:
26630 case SECOND:
26631 case SELECT:
26632 case SELF:
26633 case SEPARATE:
26634 case SET:
26635 case SHARE:
26636 case SMALLINT:
26637 case SPACE:
26638 case SQL:
26639 case SQLCODE:
26640 case SQLERRM:
26641 case START:
26642 case STATIC:
26643 case STDDEV:
26644 case SUBTYPE:
26645 case SUBSTITUTABLE:
26646 case SUCCESSFUL:
26647 case SUM:
26648 case SYNONYM:
26649 case SYSDATE:
26650 case SYS_REFCURSOR:
26651 case TABLE:
26652 case TEMPORARY:
26653 case THEN:
26654 case TIME:
26655 case TIMESTAMP:
26656 case TIMEZONE_REGION:
26657 case TIMEZONE_ABBR:
26658 case TIMEZONE_MINUTE:
26659 case TIMEZONE_HOUR:
26660 case TO:
26661 case TRANSACTION:
26662 case TRIGGER:
26663 case TRUE:
26664 case TYPE:
26665 case UI:
26666 case UNDER:
26667 case USING:
26668 case WHILE:
26669 case YES:
26670 case SHOW:
26671 case A:
26672 case UPDATE:
26673 case VARCHAR:
26674 case VARCHAR2:
26675 case DOUBLE:
26676 case DEC:
26677 case PRECISION:
26678 case INT:
26679 case NUMERIC:
26680 case SIGNTYPE:
26681 case NCHAR:
26682 case NVARCHAR2:
26683 case STRING:
26684 case UROWID:
26685 case VARRAY:
26686 case VARYING:
26687 case BFILE:
26688 case BLOB:
26689 case CLOB:
26690 case NCLOB:
26691 case YEAR:
26692 case LOCAL:
26693 case WITH:
26694 case ZONE:
26695 case CHARACTER:
26696 case AFTER:
26697 case BEFORE:
26698 case OLD:
26699 case PARENT:
26700 case ANALYZE:
26701 case ASSOCIATE:
26702 case AUDIT:
26703 case COMPOUND:
26704 case DATABASE:
26705 case CALL:
26706 case DDL:
26707 case DISASSOCIATE:
26708 case EACH:
26709 case FOLLOWS:
26710 case LOGOFF:
26711 case LOGON:
26712 case NESTED:
26713 case NOAUDIT:
26714 case SCHEMA:
26715 case SERVERERROR:
26716 case SHUTDOWN:
26717 case STARTUP:
26718 case STATEMENT:
26719 case STATISTICS:
26720 case SUSPEND:
26721 case TRUNCATE:
26722 case WRAPPED:
26723 case LIBRARY:
26724 case NAME:
26725 case STRUCT:
26726 case CONTEXT:
26727 case PARAMETERS:
26728 case LENGTH:
26729 case TDO:
26730 case MAXLEN:
26731 case CHARSETID:
26732 case CHARSETFORM:
26733 case ACCEPT:
26734 case ACCESSIBLE:
26735 case COPY:
26736 case DEFINE:
26737 case DISCONNECT:
26738 case HOST:
26739 case PRINT:
26740 case QUIT:
26741 case REMARK:
26742 case UNDEFINE:
26743 case VARIABLE:
26744 case WHENEVER:
26745 case ATTACH:
26746 case CAST:
26747 case TREAT:
26748 case TRIM:
26749 case LEFT:
26750 case RIGHT:
26751 case BOTH:
26752 case EMPTY:
26753 case MULTISET:
26754 case SUBMULTISET:
26755 case LEADING:
26756 case TRAILING:
26757 case CHAR_CS:
26758 case NCHAR_CS:
26759 case DBTIMEZONE:
26760 case SESSIONTIMEZONE:
26761 case AUTHENTICATED:
26762 case LINK:
26763 case SHARED:
26764 case DIRECTORY:
26765 case USER:
26766 case IDENTIFIER:
26767 case QUOTED_LITERAL:
26768 case SQLDATA_CLASS:
26769 case CUSTOMDATUM_CLASS:
26770 case ORADATA_CLASS:
26771 case JAVA_INTERFACE_CLASS:
26772 AttributeDeclaration();
26773 break;
26774 default:
26775 jj_la1[391] = jj_gen;
26776 jj_consume_token(-1);
26777 throw new ParseException();
26778 }
26779 }
26780 }
26781 jj_consume_token(7);
26782 break;
26783 default:
26784 jj_la1[392] = jj_gen;
26785 ;
26786 }
26787 label_92:
26788 while (true) {
26789 switch (jj_nt.kind) {
26790 case FINAL:
26791 case INSTANTIABLE:
26792 case NOT:
26793 case NULL:
26794 ;
26795 break;
26796 default:
26797 jj_la1[393] = jj_gen;
26798 break label_92;
26799 }
26800 switch (jj_nt.kind) {
26801 case NOT:
26802 jj_consume_token(NOT);
26803 break;
26804 default:
26805 jj_la1[394] = jj_gen;
26806 ;
26807 }
26808 switch (jj_nt.kind) {
26809 case FINAL:
26810 jj_consume_token(FINAL);
26811 break;
26812 case INSTANTIABLE:
26813 jj_consume_token(INSTANTIABLE);
26814 break;
26815 case NULL:
26816 jj_consume_token(NULL);
26817 break;
26818 default:
26819 jj_la1[395] = jj_gen;
26820 jj_consume_token(-1);
26821 throw new ParseException();
26822 }
26823 }
26824 switch (jj_nt.kind) {
26825 case CASCADE:
26826 case INVALIDATE:
26827 switch (jj_nt.kind) {
26828 case INVALIDATE:
26829 jj_consume_token(INVALIDATE);
26830 break;
26831 case CASCADE:
26832 jj_consume_token(CASCADE);
26833 label_93:
26834 while (true) {
26835 switch (jj_nt.kind) {
26836 case CONVERT:
26837 case INCLUDING:
26838 case NOT:
26839 ;
26840 break;
26841 default:
26842 jj_la1[396] = jj_gen;
26843 break label_93;
26844 }
26845 switch (jj_nt.kind) {
26846 case INCLUDING:
26847 case NOT:
26848 switch (jj_nt.kind) {
26849 case NOT:
26850 jj_consume_token(NOT);
26851 break;
26852 default:
26853 jj_la1[397] = jj_gen;
26854 ;
26855 }
26856 jj_consume_token(INCLUDING);
26857 jj_consume_token(TABLE);
26858 jj_consume_token(DATA);
26859 break;
26860 case CONVERT:
26861 jj_consume_token(CONVERT);
26862 jj_consume_token(TO);
26863 jj_consume_token(SUBSTITUTABLE);
26864 break;
26865 default:
26866 jj_la1[398] = jj_gen;
26867 jj_consume_token(-1);
26868 throw new ParseException();
26869 }
26870 }
26871 switch (jj_nt.kind) {
26872 case EXCEPTIONS:
26873 case FORCE:
26874 switch (jj_nt.kind) {
26875 case FORCE:
26876 jj_consume_token(FORCE);
26877 break;
26878 default:
26879 jj_la1[399] = jj_gen;
26880 ;
26881 }
26882 jj_consume_token(EXCEPTIONS);
26883 jj_consume_token(INTO);
26884 QualifiedName();
26885 break;
26886 default:
26887 jj_la1[400] = jj_gen;
26888 ;
26889 }
26890 break;
26891 default:
26892 jj_la1[401] = jj_gen;
26893 jj_consume_token(-1);
26894 throw new ParseException();
26895 }
26896 break;
26897 default:
26898 jj_la1[402] = jj_gen;
26899 ;
26900 }
26901 jjtree.closeNodeScope(jjtn000, true);
26902 jjtc000 = false;
26903 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26904 } catch (Throwable jjte000) {
26905 if (jjtc000) {
26906 jjtree.clearNodeScope(jjtn000);
26907 jjtc000 = false;
26908 } else {
26909 jjtree.popNode();
26910 }
26911 if (jjte000 instanceof RuntimeException) {
26912 {if (true) throw (RuntimeException)jjte000;}
26913 }
26914 if (jjte000 instanceof ParseException) {
26915 {if (true) throw (ParseException)jjte000;}
26916 }
26917 {if (true) throw (Error)jjte000;}
26918 } finally {
26919 if (jjtc000) {
26920 jjtree.closeNodeScope(jjtn000, true);
26921 }
26922 }
26923 throw new Error("Missing return statement in function");
26924 }
26925
26926
26927
26928
26929
26930
26931
26932
26933
26934
26935
26936
26937
26938
26939
26940
26941
26942
26943
26944
26945
26946
26947
26948
26949
26950
26951
26952
26953
26954 final public ASTAttributeDeclaration AttributeDeclaration() throws ParseException {
26955
26956 ASTAttributeDeclaration jjtn000 = new ASTAttributeDeclaration(this, JJTATTRIBUTEDECLARATION);
26957 boolean jjtc000 = true;
26958 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26959 try {
26960 simpleNode = ID();
26961 Datatype();
26962 jjtree.closeNodeScope(jjtn000, true);
26963 jjtc000 = false;
26964 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26965 } catch (Throwable jjte000) {
26966 if (jjtc000) {
26967 jjtree.clearNodeScope(jjtn000);
26968 jjtc000 = false;
26969 } else {
26970 jjtree.popNode();
26971 }
26972 if (jjte000 instanceof RuntimeException) {
26973 {if (true) throw (RuntimeException)jjte000;}
26974 }
26975 if (jjte000 instanceof ParseException) {
26976 {if (true) throw (ParseException)jjte000;}
26977 }
26978 {if (true) throw (Error)jjte000;}
26979 } finally {
26980 if (jjtc000) {
26981 jjtree.closeNodeScope(jjtn000, true);
26982 }
26983 }
26984 throw new Error("Missing return statement in function");
26985 }
26986
26987 final public ASTAttribute Attribute() throws ParseException {
26988
26989 ASTAttribute jjtn000 = new ASTAttribute(this, JJTATTRIBUTE);
26990 boolean jjtc000 = true;
26991 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26992 try {
26993 simpleNode = ID();
26994 jjtree.closeNodeScope(jjtn000, true);
26995 jjtc000 = false;
26996 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26997 } catch (Throwable jjte000) {
26998 if (jjtc000) {
26999 jjtree.clearNodeScope(jjtn000);
27000 jjtc000 = false;
27001 } else {
27002 jjtree.popNode();
27003 }
27004 if (jjte000 instanceof RuntimeException) {
27005 {if (true) throw (RuntimeException)jjte000;}
27006 }
27007 if (jjte000 instanceof ParseException) {
27008 {if (true) throw (ParseException)jjte000;}
27009 }
27010 {if (true) throw (Error)jjte000;}
27011 } finally {
27012 if (jjtc000) {
27013 jjtree.closeNodeScope(jjtn000, true);
27014 }
27015 }
27016 throw new Error("Missing return statement in function");
27017 }
27018
27019
27020
27021
27022 final public ASTPragmaClause PragmaClause() throws ParseException {
27023
27024 ASTPragmaClause jjtn000 = new ASTPragmaClause(this, JJTPRAGMACLAUSE);
27025 boolean jjtc000 = true;
27026 jjtree.openNodeScope(jjtn000);
27027 try {
27028 jj_consume_token(PRAGMA);
27029 switch (jj_nt.kind) {
27030 case SERIALLY_REUSABLE:
27031 jj_consume_token(SERIALLY_REUSABLE);
27032 break;
27033 case AUTONOMOUS_TRANSACTION:
27034 jj_consume_token(AUTONOMOUS_TRANSACTION);
27035 break;
27036 case RESTRICT_REFERENCES:
27037 jj_consume_token(RESTRICT_REFERENCES);
27038 jj_consume_token(5);
27039 ID();
27040 label_94:
27041 while (true) {
27042 jj_consume_token(6);
27043 switch (jj_nt.kind) {
27044 case REPLACE:
27045 case DEFINER:
27046 case CURRENT_USER:
27047 case SERIALLY_REUSABLE:
27048 case RESTRICT_REFERENCES:
27049 case EXCEPTION_INIT:
27050 case AUTONOMOUS_TRANSACTION:
27051 case LANGUAGE:
27052 case INLINE:
27053 case ADD:
27054 case AGGREGATE:
27055 case ALL:
27056 case ALTER:
27057 case AND:
27058 case ANY:
27059 case ARRAY:
27060 case AS:
27061 case ASC:
27062 case AT:
27063 case ATTRIBUTE:
27064 case AUTHID:
27065 case AVG:
27066 case BETWEEN:
27067 case BINARY_INTEGER:
27068 case BODY:
27069 case BOOLEAN:
27070 case BULK:
27071 case BY:
27072 case BYTE:
27073 case CASCADE:
27074 case CASE:
27075 case CHAR:
27076 case CHAR_BASE:
27077 case CHECK:
27078 case CLOSE:
27079 case CLUSTER:
27080 case COALESCE:
27081 case COLLECT:
27082 case COLUMN:
27083 case COMMENT:
27084 case COMMIT:
27085 case COMPRESS:
27086 case CONNECT:
27087 case CONSTANT:
27088 case CONSTRUCTOR:
27089 case CONTINUE:
27090 case CONVERT:
27091 case CREATE:
27092 case CURRENT:
27093 case CURRVAL:
27094 case CURSOR:
27095 case DATA:
27096 case DATE:
27097 case DAY:
27098 case DECLARE:
27099 case DECIMAL:
27100 case _DEFAULT:
27101 case DELETE:
27102 case DESC:
27103 case DISABLE:
27104 case DISTINCT:
27105 case DO:
27106 case DROP:
27107 case EDITIONABLE:
27108 case ELEMENT:
27109 case ELSE:
27110 case ELSIF:
27111 case ENABLE:
27112 case ESCAPE:
27113 case EXCEPT:
27114 case EXCEPTION:
27115 case EXCEPTIONS:
27116 case EXCLUSIVE:
27117 case EXECUTE:
27118 case EXISTS:
27119 case EXIT:
27120 case EXTERNAL:
27121 case EXTENDS:
27122 case EXTRACT:
27123 case FALSE:
27124 case FETCH:
27125 case FINAL:
27126 case FLOAT:
27127 case FOR:
27128 case FORALL:
27129 case FORCE:
27130 case FROM:
27131 case FUNCTION:
27132 case GLOBAL:
27133 case GOTO:
27134 case GROUP:
27135 case HASH:
27136 case HAVING:
27137 case HEAP:
27138 case HOUR:
27139 case IF:
27140 case IMMEDIATE:
27141 case IN:
27142 case INDEX:
27143 case INDICES:
27144 case INDEXTYPE:
27145 case INDICATOR:
27146 case INSERT:
27147 case INSTANTIABLE:
27148 case INTEGER:
27149 case INTERFACE:
27150 case INTERSECT:
27151 case INTERVAL:
27152 case INTO:
27153 case INVALIDATE:
27154 case IS:
27155 case ISOLATION:
27156 case JAVA:
27157 case LEVEL:
27158 case LIKE:
27159 case LIMIT:
27160 case LIMITED:
27161 case LOCK:
27162 case LONG:
27163 case LOOP:
27164 case MAP:
27165 case MAX:
27166 case MEMBER:
27167 case MERGE:
27168 case MIN:
27169 case MINUS:
27170 case MINUTE:
27171 case MLSLABEL:
27172 case MODIFY:
27173 case MOD:
27174 case MODE:
27175 case MONTH:
27176 case NATURAL:
27177 case NATURALN:
27178 case NEW:
27179 case NEXTVAL:
27180 case NO:
27181 case NOCOPY:
27182 case NONEDITIONABLE:
27183 case NOT:
27184 case NOWAIT:
27185 case NULL:
27186 case NULLIF:
27187 case NUMBER:
27188 case BFILE_BASE:
27189 case BLOB_BASE:
27190 case CLOB_BASE:
27191 case DATE_BASE:
27192 case NUMBER_BASE:
27193 case OBJECT:
27194 case OCIROWID:
27195 case OF:
27196 case OID:
27197 case ON:
27198 case OPAQUE:
27199 case OPEN:
27200 case OPERATOR:
27201 case OPTION:
27202 case OR:
27203 case ORDER:
27204 case ORGANIZATION:
27205 case OTHERS:
27206 case OUT:
27207 case OVERRIDING:
27208 case PACKAGE:
27209 case PARTITION:
27210 case PCTFREE:
27211 case PLS_INTEGER:
27212 case POSITIVE:
27213 case POSITIVEN:
27214 case PRESERVE:
27215 case PRIOR:
27216 case PROMPT:
27217 case PRIVATE:
27218 case PROCEDURE:
27219 case PUBLIC:
27220 case RAISE:
27221 case RANGE:
27222 case RAW:
27223 case REAL:
27224 case RECORD:
27225 case REF:
27226 case RELEASE:
27227 case RELIES_ON:
27228 case RENAME:
27229 case RESULT:
27230 case RETURN:
27231 case RETURNING:
27232 case REVERSE:
27233 case ROLLBACK:
27234 case ROW:
27235 case ROWS:
27236 case ROWID:
27237 case ROWNUM:
27238 case ROWTYPE:
27239 case SAVE:
27240 case SAVEPOINT:
27241 case SECOND:
27242 case SELECT:
27243 case SELF:
27244 case SEPARATE:
27245 case SET:
27246 case SHARE:
27247 case SMALLINT:
27248 case SPACE:
27249 case SQL:
27250 case SQLCODE:
27251 case SQLERRM:
27252 case START:
27253 case STATIC:
27254 case STDDEV:
27255 case SUBTYPE:
27256 case SUBSTITUTABLE:
27257 case SUCCESSFUL:
27258 case SUM:
27259 case SYNONYM:
27260 case SYSDATE:
27261 case SYS_REFCURSOR:
27262 case TABLE:
27263 case TEMPORARY:
27264 case THEN:
27265 case TIME:
27266 case TIMESTAMP:
27267 case TIMEZONE_REGION:
27268 case TIMEZONE_ABBR:
27269 case TIMEZONE_MINUTE:
27270 case TIMEZONE_HOUR:
27271 case TO:
27272 case TRANSACTION:
27273 case TRIGGER:
27274 case TRUE:
27275 case TYPE:
27276 case UI:
27277 case UNDER:
27278 case USING:
27279 case WHILE:
27280 case YES:
27281 case SHOW:
27282 case A:
27283 case UPDATE:
27284 case VARCHAR:
27285 case VARCHAR2:
27286 case DOUBLE:
27287 case DEC:
27288 case PRECISION:
27289 case INT:
27290 case NUMERIC:
27291 case SIGNTYPE:
27292 case NCHAR:
27293 case NVARCHAR2:
27294 case STRING:
27295 case UROWID:
27296 case VARRAY:
27297 case VARYING:
27298 case BFILE:
27299 case BLOB:
27300 case CLOB:
27301 case NCLOB:
27302 case YEAR:
27303 case LOCAL:
27304 case WITH:
27305 case ZONE:
27306 case CHARACTER:
27307 case AFTER:
27308 case BEFORE:
27309 case OLD:
27310 case PARENT:
27311 case ANALYZE:
27312 case ASSOCIATE:
27313 case AUDIT:
27314 case COMPOUND:
27315 case DATABASE:
27316 case CALL:
27317 case DDL:
27318 case DISASSOCIATE:
27319 case EACH:
27320 case FOLLOWS:
27321 case LOGOFF:
27322 case LOGON:
27323 case NESTED:
27324 case NOAUDIT:
27325 case SCHEMA:
27326 case SERVERERROR:
27327 case SHUTDOWN:
27328 case STARTUP:
27329 case STATEMENT:
27330 case STATISTICS:
27331 case SUSPEND:
27332 case TRUNCATE:
27333 case WRAPPED:
27334 case LIBRARY:
27335 case NAME:
27336 case STRUCT:
27337 case CONTEXT:
27338 case PARAMETERS:
27339 case LENGTH:
27340 case TDO:
27341 case MAXLEN:
27342 case CHARSETID:
27343 case CHARSETFORM:
27344 case ACCEPT:
27345 case ACCESSIBLE:
27346 case COPY:
27347 case DEFINE:
27348 case DISCONNECT:
27349 case HOST:
27350 case PRINT:
27351 case QUIT:
27352 case REMARK:
27353 case UNDEFINE:
27354 case VARIABLE:
27355 case WHENEVER:
27356 case ATTACH:
27357 case CAST:
27358 case TREAT:
27359 case TRIM:
27360 case LEFT:
27361 case RIGHT:
27362 case BOTH:
27363 case EMPTY:
27364 case MULTISET:
27365 case SUBMULTISET:
27366 case LEADING:
27367 case TRAILING:
27368 case CHAR_CS:
27369 case NCHAR_CS:
27370 case DBTIMEZONE:
27371 case SESSIONTIMEZONE:
27372 case AUTHENTICATED:
27373 case LINK:
27374 case SHARED:
27375 case DIRECTORY:
27376 case USER:
27377 case IDENTIFIER:
27378 case QUOTED_LITERAL:
27379 case SQLDATA_CLASS:
27380 case CUSTOMDATUM_CLASS:
27381 case ORADATA_CLASS:
27382 case JAVA_INTERFACE_CLASS:
27383 ID();
27384 break;
27385 case STRING_LITERAL:
27386 StringLiteral();
27387 break;
27388 default:
27389 jj_la1[403] = jj_gen;
27390 jj_consume_token(-1);
27391 throw new ParseException();
27392 }
27393 switch (jj_nt.kind) {
27394 case 6:
27395 ;
27396 break;
27397 default:
27398 jj_la1[404] = jj_gen;
27399 break label_94;
27400 }
27401 }
27402 jj_consume_token(7);
27403 break;
27404 case EXCEPTION_INIT:
27405 jj_consume_token(EXCEPTION_INIT);
27406 jj_consume_token(5);
27407 jj_consume_token(IDENTIFIER);
27408 jj_consume_token(6);
27409 switch (jj_nt.kind) {
27410 case 16:
27411 case 17:
27412 switch (jj_nt.kind) {
27413 case 16:
27414 jj_consume_token(16);
27415 break;
27416 case 17:
27417 jj_consume_token(17);
27418 break;
27419 default:
27420 jj_la1[405] = jj_gen;
27421 jj_consume_token(-1);
27422 throw new ParseException();
27423 }
27424 break;
27425 default:
27426 jj_la1[406] = jj_gen;
27427 ;
27428 }
27429 NumericLiteral();
27430 jj_consume_token(7);
27431 break;
27432 case INTERFACE:
27433 jj_consume_token(INTERFACE);
27434 jj_consume_token(5);
27435 jj_consume_token(IDENTIFIER);
27436 jj_consume_token(6);
27437 jj_consume_token(IDENTIFIER);
27438 jj_consume_token(6);
27439 NumericLiteral();
27440 jj_consume_token(7);
27441 break;
27442 default:
27443 jj_la1[407] = jj_gen;
27444 jj_consume_token(-1);
27445 throw new ParseException();
27446 }
27447 jjtree.closeNodeScope(jjtn000, true);
27448 jjtc000 = false;
27449 {if (true) return jjtn000 ;}
27450 } catch (Throwable jjte000) {
27451 if (jjtc000) {
27452 jjtree.clearNodeScope(jjtn000);
27453 jjtc000 = false;
27454 } else {
27455 jjtree.popNode();
27456 }
27457 if (jjte000 instanceof RuntimeException) {
27458 {if (true) throw (RuntimeException)jjte000;}
27459 }
27460 if (jjte000 instanceof ParseException) {
27461 {if (true) throw (ParseException)jjte000;}
27462 }
27463 {if (true) throw (Error)jjte000;}
27464 } finally {
27465 if (jjtc000) {
27466 jjtree.closeNodeScope(jjtn000, true);
27467 }
27468 }
27469 throw new Error("Missing return statement in function");
27470 }
27471
27472
27473
27474
27475
27476
27477
27478
27479
27480
27481
27482
27483
27484
27485
27486
27487
27488
27489
27490
27491
27492
27493
27494
27495
27496
27497
27498
27499
27500
27501
27502
27503
27504
27505
27506
27507
27508
27509
27510
27511
27512
27513
27514
27515
27516
27517
27518
27519
27520
27521
27522
27523
27524
27525
27526
27527
27528
27529
27530
27531
27532
27533
27534
27535
27536
27537
27538
27539
27540
27541
27542
27543
27544
27545
27546 final public ASTTriggerUnit TriggerUnit() throws ParseException {
27547
27548 ASTTriggerUnit jjtn000 = new ASTTriggerUnit(this, JJTTRIGGERUNIT);
27549 boolean jjtc000 = true;
27550 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
27551 try {
27552 switch (jj_nt.kind) {
27553 case CREATE:
27554 jj_consume_token(CREATE);
27555 switch (jj_nt.kind) {
27556 case OR:
27557 jj_consume_token(OR);
27558 jj_consume_token(REPLACE);
27559 break;
27560 default:
27561 jj_la1[408] = jj_gen;
27562 ;
27563 }
27564 switch (jj_nt.kind) {
27565 case EDITIONABLE:
27566 case NONEDITIONABLE:
27567 switch (jj_nt.kind) {
27568 case EDITIONABLE:
27569 jj_consume_token(EDITIONABLE);
27570 break;
27571 case NONEDITIONABLE:
27572 jj_consume_token(NONEDITIONABLE);
27573 break;
27574 default:
27575 jj_la1[409] = jj_gen;
27576 jj_consume_token(-1);
27577 throw new ParseException();
27578 }
27579 break;
27580 default:
27581 jj_la1[410] = jj_gen;
27582 ;
27583 }
27584 break;
27585 default:
27586 jj_la1[411] = jj_gen;
27587 ;
27588 }
27589 jj_consume_token(TRIGGER);
27590 simpleNode = ObjectNameDeclaration();
27591 switch (jj_nt.kind) {
27592 case BEFORE:
27593 jj_consume_token(BEFORE);
27594 break;
27595 case AFTER:
27596 jj_consume_token(AFTER);
27597 break;
27598 case INSTEADOF:
27599 jj_consume_token(INSTEADOF);
27600 break;
27601 case FOR:
27602 jj_consume_token(FOR);
27603 break;
27604 default:
27605 jj_la1[412] = jj_gen;
27606 jj_consume_token(-1);
27607 throw new ParseException();
27608 }
27609 switch (jj_nt.kind) {
27610 case DELETE:
27611 case INSERT:
27612 case UPDATE:
27613 switch (jj_nt.kind) {
27614 case DELETE:
27615 jj_consume_token(DELETE);
27616 break;
27617 case INSERT:
27618 jj_consume_token(INSERT);
27619 break;
27620 case UPDATE:
27621 jj_consume_token(UPDATE);
27622 break;
27623 default:
27624 jj_la1[413] = jj_gen;
27625 jj_consume_token(-1);
27626 throw new ParseException();
27627 }
27628 if (jj_2_74(6)) {
27629 jj_consume_token(OF);
27630 ID();
27631 label_95:
27632 while (true) {
27633 switch (jj_nt.kind) {
27634 case 6:
27635 ;
27636 break;
27637 default:
27638 jj_la1[414] = jj_gen;
27639 break label_95;
27640 }
27641 jj_consume_token(6);
27642 ID();
27643 }
27644 } else {
27645 ;
27646 }
27647 break;
27648 case ALTER:
27649 case COMMENT:
27650 case CREATE:
27651 case DROP:
27652 case GRANT:
27653 case RENAME:
27654 case REVOKE:
27655 case ANALYZE:
27656 case ASSOCIATE:
27657 case AUDIT:
27658 case DDL:
27659 case DISASSOCIATE:
27660 case LOGOFF:
27661 case LOGON:
27662 case NOAUDIT:
27663 case SERVERERROR:
27664 case SHUTDOWN:
27665 case STARTUP:
27666 case SUSPEND:
27667 case TRUNCATE:
27668 NonDMLEvent();
27669 break;
27670 default:
27671 jj_la1[415] = jj_gen;
27672 jj_consume_token(-1);
27673 throw new ParseException();
27674 }
27675 label_96:
27676 while (true) {
27677 switch (jj_nt.kind) {
27678 case OR:
27679 ;
27680 break;
27681 default:
27682 jj_la1[416] = jj_gen;
27683 break label_96;
27684 }
27685 jj_consume_token(OR);
27686 switch (jj_nt.kind) {
27687 case DELETE:
27688 case INSERT:
27689 case UPDATE:
27690 switch (jj_nt.kind) {
27691 case DELETE:
27692 jj_consume_token(DELETE);
27693 break;
27694 case INSERT:
27695 jj_consume_token(INSERT);
27696 break;
27697 case UPDATE:
27698 jj_consume_token(UPDATE);
27699 break;
27700 default:
27701 jj_la1[417] = jj_gen;
27702 jj_consume_token(-1);
27703 throw new ParseException();
27704 }
27705 if (jj_2_75(6)) {
27706 jj_consume_token(OF);
27707 ID();
27708 label_97:
27709 while (true) {
27710 switch (jj_nt.kind) {
27711 case 6:
27712 ;
27713 break;
27714 default:
27715 jj_la1[418] = jj_gen;
27716 break label_97;
27717 }
27718 jj_consume_token(6);
27719 ID();
27720 }
27721 } else {
27722 ;
27723 }
27724 break;
27725 case ALTER:
27726 case COMMENT:
27727 case CREATE:
27728 case DROP:
27729 case GRANT:
27730 case RENAME:
27731 case REVOKE:
27732 case ANALYZE:
27733 case ASSOCIATE:
27734 case AUDIT:
27735 case DDL:
27736 case DISASSOCIATE:
27737 case LOGOFF:
27738 case LOGON:
27739 case NOAUDIT:
27740 case SERVERERROR:
27741 case SHUTDOWN:
27742 case STARTUP:
27743 case SUSPEND:
27744 case TRUNCATE:
27745 NonDMLEvent();
27746 break;
27747 default:
27748 jj_la1[419] = jj_gen;
27749 jj_consume_token(-1);
27750 throw new ParseException();
27751 }
27752 }
27753 jj_consume_token(ON);
27754 switch (jj_nt.kind) {
27755 case DATABASE:
27756 jj_consume_token(DATABASE);
27757 break;
27758 default:
27759 jj_la1[420] = jj_gen;
27760 if (jj_2_78(2)) {
27761 jj_consume_token(NESTED);
27762 jj_consume_token(TABLE);
27763 ID();
27764 jj_consume_token(OF);
27765 if (jj_2_76(2)) {
27766 ID();
27767 jj_consume_token(3);
27768 } else {
27769 ;
27770 }
27771 ID();
27772 } else {
27773 switch (jj_nt.kind) {
27774 case REPLACE:
27775 case DEFINER:
27776 case CURRENT_USER:
27777 case SERIALLY_REUSABLE:
27778 case RESTRICT_REFERENCES:
27779 case EXCEPTION_INIT:
27780 case AUTONOMOUS_TRANSACTION:
27781 case LANGUAGE:
27782 case INLINE:
27783 case ADD:
27784 case AGGREGATE:
27785 case ALL:
27786 case ALTER:
27787 case AND:
27788 case ANY:
27789 case ARRAY:
27790 case AS:
27791 case ASC:
27792 case AT:
27793 case ATTRIBUTE:
27794 case AUTHID:
27795 case AVG:
27796 case BETWEEN:
27797 case BINARY_INTEGER:
27798 case BODY:
27799 case BOOLEAN:
27800 case BULK:
27801 case BY:
27802 case BYTE:
27803 case CASCADE:
27804 case CASE:
27805 case CHAR:
27806 case CHAR_BASE:
27807 case CHECK:
27808 case CLOSE:
27809 case CLUSTER:
27810 case COALESCE:
27811 case COLLECT:
27812 case COLUMN:
27813 case COMMENT:
27814 case COMMIT:
27815 case COMPRESS:
27816 case CONNECT:
27817 case CONSTANT:
27818 case CONSTRUCTOR:
27819 case CONTINUE:
27820 case CONVERT:
27821 case CREATE:
27822 case CURRENT:
27823 case CURRVAL:
27824 case CURSOR:
27825 case DATA:
27826 case DATE:
27827 case DAY:
27828 case DECLARE:
27829 case DECIMAL:
27830 case _DEFAULT:
27831 case DELETE:
27832 case DESC:
27833 case DISABLE:
27834 case DISTINCT:
27835 case DO:
27836 case DROP:
27837 case EDITIONABLE:
27838 case ELEMENT:
27839 case ELSE:
27840 case ELSIF:
27841 case ENABLE:
27842 case ESCAPE:
27843 case EXCEPT:
27844 case EXCEPTION:
27845 case EXCEPTIONS:
27846 case EXCLUSIVE:
27847 case EXECUTE:
27848 case EXISTS:
27849 case EXIT:
27850 case EXTERNAL:
27851 case EXTENDS:
27852 case EXTRACT:
27853 case FALSE:
27854 case FETCH:
27855 case FINAL:
27856 case FLOAT:
27857 case FOR:
27858 case FORALL:
27859 case FORCE:
27860 case FROM:
27861 case FUNCTION:
27862 case GLOBAL:
27863 case GOTO:
27864 case GROUP:
27865 case HASH:
27866 case HAVING:
27867 case HEAP:
27868 case HOUR:
27869 case IF:
27870 case IMMEDIATE:
27871 case IN:
27872 case INDEX:
27873 case INDICES:
27874 case INDEXTYPE:
27875 case INDICATOR:
27876 case INSERT:
27877 case INSTANTIABLE:
27878 case INTEGER:
27879 case INTERFACE:
27880 case INTERSECT:
27881 case INTERVAL:
27882 case INTO:
27883 case INVALIDATE:
27884 case IS:
27885 case ISOLATION:
27886 case JAVA:
27887 case LEVEL:
27888 case LIKE:
27889 case LIMIT:
27890 case LIMITED:
27891 case LOCK:
27892 case LONG:
27893 case LOOP:
27894 case MAP:
27895 case MAX:
27896 case MEMBER:
27897 case MERGE:
27898 case MIN:
27899 case MINUS:
27900 case MINUTE:
27901 case MLSLABEL:
27902 case MODIFY:
27903 case MOD:
27904 case MODE:
27905 case MONTH:
27906 case NATURAL:
27907 case NATURALN:
27908 case NEW:
27909 case NEXTVAL:
27910 case NO:
27911 case NOCOPY:
27912 case NONEDITIONABLE:
27913 case NOT:
27914 case NOWAIT:
27915 case NULL:
27916 case NULLIF:
27917 case NUMBER:
27918 case BFILE_BASE:
27919 case BLOB_BASE:
27920 case CLOB_BASE:
27921 case DATE_BASE:
27922 case NUMBER_BASE:
27923 case OBJECT:
27924 case OCIROWID:
27925 case OF:
27926 case OID:
27927 case ON:
27928 case OPAQUE:
27929 case OPEN:
27930 case OPERATOR:
27931 case OPTION:
27932 case OR:
27933 case ORDER:
27934 case ORGANIZATION:
27935 case OTHERS:
27936 case OUT:
27937 case OVERRIDING:
27938 case PACKAGE:
27939 case PARTITION:
27940 case PCTFREE:
27941 case PLS_INTEGER:
27942 case POSITIVE:
27943 case POSITIVEN:
27944 case PRESERVE:
27945 case PRIOR:
27946 case PROMPT:
27947 case PRIVATE:
27948 case PROCEDURE:
27949 case PUBLIC:
27950 case RAISE:
27951 case RANGE:
27952 case RAW:
27953 case REAL:
27954 case RECORD:
27955 case REF:
27956 case RELEASE:
27957 case RELIES_ON:
27958 case RENAME:
27959 case RESULT:
27960 case RETURN:
27961 case RETURNING:
27962 case REVERSE:
27963 case ROLLBACK:
27964 case ROW:
27965 case ROWS:
27966 case ROWID:
27967 case ROWNUM:
27968 case ROWTYPE:
27969 case SAVE:
27970 case SAVEPOINT:
27971 case SECOND:
27972 case SELECT:
27973 case SELF:
27974 case SEPARATE:
27975 case SET:
27976 case SHARE:
27977 case SMALLINT:
27978 case SPACE:
27979 case SQL:
27980 case SQLCODE:
27981 case SQLERRM:
27982 case START:
27983 case STATIC:
27984 case STDDEV:
27985 case SUBTYPE:
27986 case SUBSTITUTABLE:
27987 case SUCCESSFUL:
27988 case SUM:
27989 case SYNONYM:
27990 case SYSDATE:
27991 case SYS_REFCURSOR:
27992 case TABLE:
27993 case TEMPORARY:
27994 case THEN:
27995 case TIME:
27996 case TIMESTAMP:
27997 case TIMEZONE_REGION:
27998 case TIMEZONE_ABBR:
27999 case TIMEZONE_MINUTE:
28000 case TIMEZONE_HOUR:
28001 case TO:
28002 case TRANSACTION:
28003 case TRIGGER:
28004 case TRUE:
28005 case TYPE:
28006 case UI:
28007 case UNDER:
28008 case USING:
28009 case WHILE:
28010 case YES:
28011 case SHOW:
28012 case A:
28013 case UPDATE:
28014 case VARCHAR:
28015 case VARCHAR2:
28016 case DOUBLE:
28017 case DEC:
28018 case PRECISION:
28019 case INT:
28020 case NUMERIC:
28021 case SIGNTYPE:
28022 case NCHAR:
28023 case NVARCHAR2:
28024 case STRING:
28025 case UROWID:
28026 case VARRAY:
28027 case VARYING:
28028 case BFILE:
28029 case BLOB:
28030 case CLOB:
28031 case NCLOB:
28032 case YEAR:
28033 case LOCAL:
28034 case WITH:
28035 case ZONE:
28036 case CHARACTER:
28037 case AFTER:
28038 case BEFORE:
28039 case OLD:
28040 case PARENT:
28041 case ANALYZE:
28042 case ASSOCIATE:
28043 case AUDIT:
28044 case COMPOUND:
28045 case DATABASE:
28046 case CALL:
28047 case DDL:
28048 case DISASSOCIATE:
28049 case EACH:
28050 case FOLLOWS:
28051 case LOGOFF:
28052 case LOGON:
28053 case NESTED:
28054 case NOAUDIT:
28055 case SCHEMA:
28056 case SERVERERROR:
28057 case SHUTDOWN:
28058 case STARTUP:
28059 case STATEMENT:
28060 case STATISTICS:
28061 case SUSPEND:
28062 case TRUNCATE:
28063 case WRAPPED:
28064 case LIBRARY:
28065 case NAME:
28066 case STRUCT:
28067 case CONTEXT:
28068 case PARAMETERS:
28069 case LENGTH:
28070 case TDO:
28071 case MAXLEN:
28072 case CHARSETID:
28073 case CHARSETFORM:
28074 case ACCEPT:
28075 case ACCESSIBLE:
28076 case COPY:
28077 case DEFINE:
28078 case DISCONNECT:
28079 case HOST:
28080 case PRINT:
28081 case QUIT:
28082 case REMARK:
28083 case UNDEFINE:
28084 case VARIABLE:
28085 case WHENEVER:
28086 case ATTACH:
28087 case CAST:
28088 case TREAT:
28089 case TRIM:
28090 case LEFT:
28091 case RIGHT:
28092 case BOTH:
28093 case EMPTY:
28094 case MULTISET:
28095 case SUBMULTISET:
28096 case LEADING:
28097 case TRAILING:
28098 case CHAR_CS:
28099 case NCHAR_CS:
28100 case DBTIMEZONE:
28101 case SESSIONTIMEZONE:
28102 case AUTHENTICATED:
28103 case LINK:
28104 case SHARED:
28105 case DIRECTORY:
28106 case USER:
28107 case IDENTIFIER:
28108 case QUOTED_LITERAL:
28109 case SQLDATA_CLASS:
28110 case CUSTOMDATUM_CLASS:
28111 case ORADATA_CLASS:
28112 case JAVA_INTERFACE_CLASS:
28113 if (jj_2_77(2)) {
28114 ID();
28115 jj_consume_token(3);
28116 } else {
28117 ;
28118 }
28119 ID();
28120 break;
28121 default:
28122 jj_la1[421] = jj_gen;
28123 jj_consume_token(-1);
28124 throw new ParseException();
28125 }
28126 }
28127 }
28128 switch (jj_nt.kind) {
28129 case REFERENCING:
28130 jj_consume_token(REFERENCING);
28131 label_98:
28132 while (true) {
28133 switch (jj_nt.kind) {
28134 case NEW:
28135 case OLD:
28136 case PARENT:
28137 ;
28138 break;
28139 default:
28140 jj_la1[422] = jj_gen;
28141 break label_98;
28142 }
28143 switch (jj_nt.kind) {
28144 case OLD:
28145 jj_consume_token(OLD);
28146 break;
28147 case NEW:
28148 jj_consume_token(NEW);
28149 break;
28150 case PARENT:
28151 jj_consume_token(PARENT);
28152 break;
28153 default:
28154 jj_la1[423] = jj_gen;
28155 jj_consume_token(-1);
28156 throw new ParseException();
28157 }
28158 jj_consume_token(AS);
28159 ID();
28160 }
28161 break;
28162 default:
28163 jj_la1[424] = jj_gen;
28164 ;
28165 }
28166 switch (jj_nt.kind) {
28167 case FOREACHROW:
28168 jj_consume_token(FOREACHROW);
28169 break;
28170 default:
28171 jj_la1[425] = jj_gen;
28172 ;
28173 }
28174 switch (jj_nt.kind) {
28175 case REVERSE:
28176 case FORWARD:
28177 case CROSSEDITION:
28178 switch (jj_nt.kind) {
28179 case REVERSE:
28180 case FORWARD:
28181 switch (jj_nt.kind) {
28182 case FORWARD:
28183 jj_consume_token(FORWARD);
28184 break;
28185 case REVERSE:
28186 jj_consume_token(REVERSE);
28187 break;
28188 default:
28189 jj_la1[426] = jj_gen;
28190 jj_consume_token(-1);
28191 throw new ParseException();
28192 }
28193 break;
28194 default:
28195 jj_la1[427] = jj_gen;
28196 ;
28197 }
28198 jj_consume_token(CROSSEDITION);
28199 break;
28200 default:
28201 jj_la1[428] = jj_gen;
28202 ;
28203 }
28204 switch (jj_nt.kind) {
28205 case FOLLOWS:
28206 case PRECEDES:
28207 switch (jj_nt.kind) {
28208 case FOLLOWS:
28209 jj_consume_token(FOLLOWS);
28210 break;
28211 case PRECEDES:
28212 jj_consume_token(PRECEDES);
28213 break;
28214 default:
28215 jj_la1[429] = jj_gen;
28216 jj_consume_token(-1);
28217 throw new ParseException();
28218 }
28219 if (jj_2_79(2)) {
28220 ID();
28221 jj_consume_token(3);
28222 } else {
28223 ;
28224 }
28225 ID();
28226 label_99:
28227 while (true) {
28228 switch (jj_nt.kind) {
28229 case 6:
28230 ;
28231 break;
28232 default:
28233 jj_la1[430] = jj_gen;
28234 break label_99;
28235 }
28236 jj_consume_token(6);
28237 if (jj_2_80(2)) {
28238 ID();
28239 jj_consume_token(3);
28240 } else {
28241 ;
28242 }
28243 ID();
28244 }
28245 break;
28246 default:
28247 jj_la1[431] = jj_gen;
28248 ;
28249 }
28250 switch (jj_nt.kind) {
28251 case DISABLE:
28252 case ENABLE:
28253 switch (jj_nt.kind) {
28254 case ENABLE:
28255 jj_consume_token(ENABLE);
28256 break;
28257 case DISABLE:
28258 jj_consume_token(DISABLE);
28259 break;
28260 default:
28261 jj_la1[432] = jj_gen;
28262 jj_consume_token(-1);
28263 throw new ParseException();
28264 }
28265 break;
28266 default:
28267 jj_la1[433] = jj_gen;
28268 ;
28269 }
28270 switch (jj_nt.kind) {
28271 case WHEN:
28272 jj_consume_token(WHEN);
28273 jj_consume_token(5);
28274 ConditionalOrExpression();
28275 jj_consume_token(7);
28276 break;
28277 default:
28278 jj_la1[434] = jj_gen;
28279 ;
28280 }
28281 switch (jj_nt.kind) {
28282 case CALL:
28283 jj_consume_token(CALL);
28284 PrimaryExpression();
28285 jj_consume_token(4);
28286 break;
28287 case COMPOUND:
28288 CompoundTriggerBlock();
28289 break;
28290 case BEGIN:
28291 case DECLARE:
28292 Block();
28293 jj_consume_token(4);
28294 break;
28295 default:
28296 jj_la1[435] = jj_gen;
28297 jj_consume_token(-1);
28298 throw new ParseException();
28299 }
28300 jjtree.closeNodeScope(jjtn000, true);
28301 jjtc000 = false;
28302 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
28303 } catch (Throwable jjte000) {
28304 if (jjtc000) {
28305 jjtree.clearNodeScope(jjtn000);
28306 jjtc000 = false;
28307 } else {
28308 jjtree.popNode();
28309 }
28310 if (jjte000 instanceof RuntimeException) {
28311 {if (true) throw (RuntimeException)jjte000;}
28312 }
28313 if (jjte000 instanceof ParseException) {
28314 {if (true) throw (ParseException)jjte000;}
28315 }
28316 {if (true) throw (Error)jjte000;}
28317 } finally {
28318 if (jjtc000) {
28319 jjtree.closeNodeScope(jjtn000, true);
28320 }
28321 }
28322 throw new Error("Missing return statement in function");
28323 }
28324
28325 final public ASTTriggerTimingPointSection TriggerTimingPointSection() throws ParseException {
28326
28327 ASTTriggerTimingPointSection jjtn000 = new ASTTriggerTimingPointSection(this, JJTTRIGGERTIMINGPOINTSECTION);
28328 boolean jjtc000 = true;
28329 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
28330 try {
28331 switch (jj_nt.kind) {
28332 case BEFORE:
28333 jj_consume_token(BEFORE);
28334 break;
28335 case AFTER:
28336 jj_consume_token(AFTER);
28337 break;
28338 case INSTEADOF:
28339 jj_consume_token(INSTEADOF);
28340 break;
28341 default:
28342 jj_la1[436] = jj_gen;
28343 jj_consume_token(-1);
28344 throw new ParseException();
28345 }
28346 sb.append(token.image) ;
28347 switch (jj_nt.kind) {
28348 case STATEMENT:
28349 jj_consume_token(STATEMENT);
28350 break;
28351 case EACH:
28352 jj_consume_token(EACH);
28353 jj_consume_token(ROW);
28354 break;
28355 default:
28356 jj_la1[437] = jj_gen;
28357 jj_consume_token(-1);
28358 throw new ParseException();
28359 }
28360 sb.append(" "); sb.append(token.image) ;
28361 jj_consume_token(IS);
28362 jj_consume_token(BEGIN);
28363 label_100:
28364 while (true) {
28365 Statement();
28366 switch (jj_nt.kind) {
28367 case 5:
28368 case 16:
28369 case 17:
28370 case 21:
28371 case REPLACE:
28372 case DEFINER:
28373 case CURRENT_USER:
28374 case LANGUAGE:
28375 case INLINE:
28376 case ADD:
28377 case AGGREGATE:
28378 case ARRAY:
28379 case AT:
28380 case ATTRIBUTE:
28381 case AUTHID:
28382 case BEGIN:
28383 case BODY:
28384 case BULK:
28385 case BYTE:
28386 case CASCADE:
28387 case CASE:
28388 case CLOSE:
28389 case COALESCE:
28390 case COLLECT:
28391 case COLUMN:
28392 case COMMENT:
28393 case COMMIT:
28394 case CONSTRUCTOR:
28395 case CONTINUE:
28396 case CONVERT:
28397 case CURRENT:
28398 case CURSOR:
28399 case DATA:
28400 case DATE:
28401 case DAY:
28402 case DECLARE:
28403 case DELETE:
28404 case DISABLE:
28405 case EDITIONABLE:
28406 case ELEMENT:
28407 case ENABLE:
28408 case ESCAPE:
28409 case EXCEPT:
28410 case EXCEPTIONS:
28411 case EXECUTE:
28412 case EXIT:
28413 case EXTERNAL:
28414 case EXTENDS:
28415 case EXTRACT:
28416 case FALSE:
28417 case FETCH:
28418 case FINAL:
28419 case FOR:
28420 case FORALL:
28421 case FORCE:
28422 case FUNCTION:
28423 case GLOBAL:
28424 case GOTO:
28425 case HASH:
28426 case HEAP:
28427 case HOUR:
28428 case IF:
28429 case IMMEDIATE:
28430 case INDICES:
28431 case INDEXTYPE:
28432 case INDICATOR:
28433 case INSERT:
28434 case INSTANTIABLE:
28435 case INTERVAL:
28436 case INVALIDATE:
28437 case ISOLATION:
28438 case JAVA:
28439 case LEVEL:
28440 case LIMIT:
28441 case LOCK:
28442 case LOOP:
28443 case MAP:
28444 case MAX:
28445 case MEMBER:
28446 case MERGE:
28447 case MIN:
28448 case MINUTE:
28449 case MLSLABEL:
28450 case MODIFY:
28451 case MOD:
28452 case MONTH:
28453 case NATURAL:
28454 case NEW:
28455 case NEW_DOT:
28456 case NO:
28457 case NONEDITIONABLE:
28458 case NOT:
28459 case NULL:
28460 case NULLIF:
28461 case OBJECT:
28462 case OID:
28463 case OPAQUE:
28464 case OPEN:
28465 case OPERATOR:
28466 case ORGANIZATION:
28467 case OTHERS:
28468 case OVERRIDING:
28469 case PACKAGE:
28470 case PARTITION:
28471 case PIPE:
28472 case PRAGMA:
28473 case PRESERVE:
28474 case PRIVATE:
28475 case PROCEDURE:
28476 case RAISE:
28477 case RANGE:
28478 case RAW:
28479 case REAL:
28480 case RECORD:
28481 case REF:
28482 case RELEASE:
28483 case RELIES_ON:
28484 case RENAME:
28485 case RESULT:
28486 case RETURN:
28487 case RETURNING:
28488 case REVERSE:
28489 case ROLLBACK:
28490 case ROW:
28491 case ROWS:
28492 case ROWID:
28493 case ROWNUM:
28494 case SAVE:
28495 case SAVEPOINT:
28496 case SECOND:
28497 case SELECT:
28498 case SELF:
28499 case SET:
28500 case SPACE:
28501 case SQL:
28502 case SQLCODE:
28503 case SQLERRM:
28504 case STATIC:
28505 case SUBTYPE:
28506 case SUBSTITUTABLE:
28507 case SUCCESSFUL:
28508 case SYSDATE:
28509 case SYS_REFCURSOR:
28510 case TEMPORARY:
28511 case TIME:
28512 case TIMESTAMP:
28513 case TIMEZONE_REGION:
28514 case TIMEZONE_ABBR:
28515 case TIMEZONE_MINUTE:
28516 case TIMEZONE_HOUR:
28517 case TRANSACTION:
28518 case TRUE:
28519 case TYPE:
28520 case UNDER:
28521 case USING:
28522 case WHILE:
28523 case YES:
28524 case SHOW:
28525 case A:
28526 case UPDATE:
28527 case DOUBLE:
28528 case DEC:
28529 case PRECISION:
28530 case INT:
28531 case NUMERIC:
28532 case NCHAR:
28533 case NVARCHAR2:
28534 case STRING:
28535 case UROWID:
28536 case VARRAY:
28537 case VARYING:
28538 case BFILE:
28539 case BLOB:
28540 case CLOB:
28541 case NCLOB:
28542 case YEAR:
28543 case LOCAL:
28544 case WITH:
28545 case ZONE:
28546 case CHARACTER:
28547 case AFTER:
28548 case BEFORE:
28549 case OLD:
28550 case PARENT:
28551 case CC_IF:
28552 case CC_ERROR:
28553 case ANALYZE:
28554 case ASSOCIATE:
28555 case AUDIT:
28556 case COMPOUND:
28557 case DATABASE:
28558 case CALL:
28559 case DDL:
28560 case DISASSOCIATE:
28561 case EACH:
28562 case FOLLOWS:
28563 case LOGOFF:
28564 case LOGON:
28565 case NESTED:
28566 case NOAUDIT:
28567 case SCHEMA:
28568 case SERVERERROR:
28569 case SHUTDOWN:
28570 case STARTUP:
28571 case STATEMENT:
28572 case STATISTICS:
28573 case SUSPEND:
28574 case TRUNCATE:
28575 case WRAPPED:
28576 case LIBRARY:
28577 case NAME:
28578 case STRUCT:
28579 case CONTEXT:
28580 case PARAMETERS:
28581 case LENGTH:
28582 case TDO:
28583 case MAXLEN:
28584 case CHARSETID:
28585 case CHARSETFORM:
28586 case ACCEPT:
28587 case ACCESSIBLE:
28588 case COPY:
28589 case DEFINE:
28590 case DISCONNECT:
28591 case HOST:
28592 case PRINT:
28593 case QUIT:
28594 case REMARK:
28595 case UNDEFINE:
28596 case VARIABLE:
28597 case WHENEVER:
28598 case ATTACH:
28599 case CAST:
28600 case TREAT:
28601 case TRIM:
28602 case LEFT:
28603 case RIGHT:
28604 case BOTH:
28605 case EMPTY:
28606 case MULTISET:
28607 case SUBMULTISET:
28608 case LEADING:
28609 case TRAILING:
28610 case CHAR_CS:
28611 case NCHAR_CS:
28612 case DBTIMEZONE:
28613 case SESSIONTIMEZONE:
28614 case AUTHENTICATED:
28615 case LINK:
28616 case SHARED:
28617 case DIRECTORY:
28618 case USER:
28619 case IDENTIFIER:
28620 case UNSIGNED_NUMERIC_LITERAL:
28621 case CHARACTER_LITERAL:
28622 case STRING_LITERAL:
28623 case QUOTED_LITERAL:
28624 ;
28625 break;
28626 default:
28627 jj_la1[438] = jj_gen;
28628 break label_100;
28629 }
28630 }
28631 jj_consume_token(END);
28632 switch (jj_nt.kind) {
28633 case BEFORE:
28634 jj_consume_token(BEFORE);
28635 break;
28636 case AFTER:
28637 jj_consume_token(AFTER);
28638 break;
28639 case INSTEADOF:
28640 jj_consume_token(INSTEADOF);
28641 break;
28642 default:
28643 jj_la1[439] = jj_gen;
28644 jj_consume_token(-1);
28645 throw new ParseException();
28646 }
28647 switch (jj_nt.kind) {
28648 case STATEMENT:
28649 jj_consume_token(STATEMENT);
28650 break;
28651 case EACH:
28652 jj_consume_token(EACH);
28653 jj_consume_token(ROW);
28654 break;
28655 default:
28656 jj_la1[440] = jj_gen;
28657 jj_consume_token(-1);
28658 throw new ParseException();
28659 }
28660 jj_consume_token(4);
28661
28662 jjtree.closeNodeScope(jjtn000, true);
28663 jjtc000 = false;
28664 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
28665 } catch (Throwable jjte000) {
28666 if (jjtc000) {
28667 jjtree.clearNodeScope(jjtn000);
28668 jjtc000 = false;
28669 } else {
28670 jjtree.popNode();
28671 }
28672 if (jjte000 instanceof RuntimeException) {
28673 {if (true) throw (RuntimeException)jjte000;}
28674 }
28675 if (jjte000 instanceof ParseException) {
28676 {if (true) throw (ParseException)jjte000;}
28677 }
28678 {if (true) throw (Error)jjte000;}
28679 } finally {
28680 if (jjtc000) {
28681 jjtree.closeNodeScope(jjtn000, true);
28682 }
28683 }
28684 throw new Error("Missing return statement in function");
28685 }
28686
28687 final public ASTCompoundTriggerBlock CompoundTriggerBlock() throws ParseException {
28688
28689 ASTCompoundTriggerBlock jjtn000 = new ASTCompoundTriggerBlock(this, JJTCOMPOUNDTRIGGERBLOCK);
28690 boolean jjtc000 = true;
28691 jjtree.openNodeScope(jjtn000);
28692 try {
28693 jj_consume_token(COMPOUND);
28694 jj_consume_token(TRIGGER);
28695 label_101:
28696 while (true) {
28697 switch (jj_nt.kind) {
28698 case REPLACE:
28699 case DEFINER:
28700 case CURRENT_USER:
28701 case SERIALLY_REUSABLE:
28702 case RESTRICT_REFERENCES:
28703 case EXCEPTION_INIT:
28704 case AUTONOMOUS_TRANSACTION:
28705 case LANGUAGE:
28706 case INLINE:
28707 case ADD:
28708 case AGGREGATE:
28709 case ALL:
28710 case ALTER:
28711 case AND:
28712 case ANY:
28713 case ARRAY:
28714 case AS:
28715 case ASC:
28716 case AT:
28717 case ATTRIBUTE:
28718 case AUTHID:
28719 case AVG:
28720 case BETWEEN:
28721 case BINARY_INTEGER:
28722 case BODY:
28723 case BOOLEAN:
28724 case BULK:
28725 case BY:
28726 case BYTE:
28727 case CASCADE:
28728 case CASE:
28729 case CHAR:
28730 case CHAR_BASE:
28731 case CHECK:
28732 case CLOSE:
28733 case CLUSTER:
28734 case COALESCE:
28735 case COLLECT:
28736 case COLUMN:
28737 case COMMENT:
28738 case COMMIT:
28739 case COMPRESS:
28740 case CONNECT:
28741 case CONSTANT:
28742 case CONSTRUCTOR:
28743 case CONTINUE:
28744 case CONVERT:
28745 case CREATE:
28746 case CURRENT:
28747 case CURRVAL:
28748 case CURSOR:
28749 case DATA:
28750 case DATE:
28751 case DAY:
28752 case DECLARE:
28753 case DECIMAL:
28754 case _DEFAULT:
28755 case DELETE:
28756 case DESC:
28757 case DISABLE:
28758 case DISTINCT:
28759 case DO:
28760 case DROP:
28761 case EDITIONABLE:
28762 case ELEMENT:
28763 case ELSE:
28764 case ELSIF:
28765 case ENABLE:
28766 case ESCAPE:
28767 case EXCEPT:
28768 case EXCEPTION:
28769 case EXCEPTIONS:
28770 case EXCLUSIVE:
28771 case EXECUTE:
28772 case EXISTS:
28773 case EXIT:
28774 case EXTERNAL:
28775 case EXTENDS:
28776 case EXTRACT:
28777 case FALSE:
28778 case FETCH:
28779 case FINAL:
28780 case FLOAT:
28781 case FOR:
28782 case FORALL:
28783 case FORCE:
28784 case FROM:
28785 case FUNCTION:
28786 case GLOBAL:
28787 case GOTO:
28788 case GROUP:
28789 case HASH:
28790 case HAVING:
28791 case HEAP:
28792 case HOUR:
28793 case IF:
28794 case IMMEDIATE:
28795 case IN:
28796 case INDEX:
28797 case INDICES:
28798 case INDEXTYPE:
28799 case INDICATOR:
28800 case INSERT:
28801 case INSTANTIABLE:
28802 case INTEGER:
28803 case INTERFACE:
28804 case INTERSECT:
28805 case INTERVAL:
28806 case INTO:
28807 case INVALIDATE:
28808 case IS:
28809 case ISOLATION:
28810 case JAVA:
28811 case LEVEL:
28812 case LIKE:
28813 case LIMIT:
28814 case LIMITED:
28815 case LOCK:
28816 case LONG:
28817 case LOOP:
28818 case MAP:
28819 case MAX:
28820 case MEMBER:
28821 case MERGE:
28822 case MIN:
28823 case MINUS:
28824 case MINUTE:
28825 case MLSLABEL:
28826 case MODIFY:
28827 case MOD:
28828 case MODE:
28829 case MONTH:
28830 case NATURAL:
28831 case NATURALN:
28832 case NEW:
28833 case NEXTVAL:
28834 case NO:
28835 case NOCOPY:
28836 case NONEDITIONABLE:
28837 case NOT:
28838 case NOWAIT:
28839 case NULL:
28840 case NULLIF:
28841 case NUMBER:
28842 case BFILE_BASE:
28843 case BLOB_BASE:
28844 case CLOB_BASE:
28845 case DATE_BASE:
28846 case NUMBER_BASE:
28847 case OBJECT:
28848 case OCIROWID:
28849 case OF:
28850 case OID:
28851 case ON:
28852 case OPAQUE:
28853 case OPEN:
28854 case OPERATOR:
28855 case OPTION:
28856 case OR:
28857 case ORDER:
28858 case ORGANIZATION:
28859 case OTHERS:
28860 case OUT:
28861 case OVERRIDING:
28862 case PACKAGE:
28863 case PARTITION:
28864 case PCTFREE:
28865 case PLS_INTEGER:
28866 case POSITIVE:
28867 case POSITIVEN:
28868 case PRAGMA:
28869 case PRESERVE:
28870 case PRIOR:
28871 case PROMPT:
28872 case PRIVATE:
28873 case PROCEDURE:
28874 case PUBLIC:
28875 case RAISE:
28876 case RANGE:
28877 case RAW:
28878 case REAL:
28879 case RECORD:
28880 case REF:
28881 case RELEASE:
28882 case RELIES_ON:
28883 case RENAME:
28884 case RESULT:
28885 case RETURN:
28886 case RETURNING:
28887 case REVERSE:
28888 case ROLLBACK:
28889 case ROW:
28890 case ROWS:
28891 case ROWID:
28892 case ROWNUM:
28893 case ROWTYPE:
28894 case SAVE:
28895 case SAVEPOINT:
28896 case SECOND:
28897 case SELECT:
28898 case SELF:
28899 case SEPARATE:
28900 case SET:
28901 case SHARE:
28902 case SMALLINT:
28903 case SPACE:
28904 case SQL:
28905 case SQLCODE:
28906 case SQLERRM:
28907 case START:
28908 case STATIC:
28909 case STDDEV:
28910 case SUBTYPE:
28911 case SUBSTITUTABLE:
28912 case SUCCESSFUL:
28913 case SUM:
28914 case SYNONYM:
28915 case SYSDATE:
28916 case SYS_REFCURSOR:
28917 case TABLE:
28918 case TEMPORARY:
28919 case THEN:
28920 case TIME:
28921 case TIMESTAMP:
28922 case TIMEZONE_REGION:
28923 case TIMEZONE_ABBR:
28924 case TIMEZONE_MINUTE:
28925 case TIMEZONE_HOUR:
28926 case TO:
28927 case TRANSACTION:
28928 case TRIGGER:
28929 case TRUE:
28930 case TYPE:
28931 case UI:
28932 case UNDER:
28933 case USING:
28934 case WHILE:
28935 case YES:
28936 case SHOW:
28937 case A:
28938 case UPDATE:
28939 case VARCHAR:
28940 case VARCHAR2:
28941 case DOUBLE:
28942 case DEC:
28943 case PRECISION:
28944 case INT:
28945 case NUMERIC:
28946 case SIGNTYPE:
28947 case NCHAR:
28948 case NVARCHAR2:
28949 case STRING:
28950 case UROWID:
28951 case VARRAY:
28952 case VARYING:
28953 case BFILE:
28954 case BLOB:
28955 case CLOB:
28956 case NCLOB:
28957 case YEAR:
28958 case LOCAL:
28959 case WITH:
28960 case ZONE:
28961 case CHARACTER:
28962 case AFTER:
28963 case BEFORE:
28964 case INSTEADOF:
28965 case OLD:
28966 case PARENT:
28967 case ANALYZE:
28968 case ASSOCIATE:
28969 case AUDIT:
28970 case COMPOUND:
28971 case DATABASE:
28972 case CALL:
28973 case DDL:
28974 case DISASSOCIATE:
28975 case EACH:
28976 case FOLLOWS:
28977 case LOGOFF:
28978 case LOGON:
28979 case NESTED:
28980 case NOAUDIT:
28981 case SCHEMA:
28982 case SERVERERROR:
28983 case SHUTDOWN:
28984 case STARTUP:
28985 case STATEMENT:
28986 case STATISTICS:
28987 case SUSPEND:
28988 case TRUNCATE:
28989 case WRAPPED:
28990 case LIBRARY:
28991 case NAME:
28992 case STRUCT:
28993 case CONTEXT:
28994 case PARAMETERS:
28995 case LENGTH:
28996 case TDO:
28997 case MAXLEN:
28998 case CHARSETID:
28999 case CHARSETFORM:
29000 case ACCEPT:
29001 case ACCESSIBLE:
29002 case COPY:
29003 case DEFINE:
29004 case DISCONNECT:
29005 case HOST:
29006 case PRINT:
29007 case QUIT:
29008 case REMARK:
29009 case UNDEFINE:
29010 case VARIABLE:
29011 case WHENEVER:
29012 case ATTACH:
29013 case CAST:
29014 case TREAT:
29015 case TRIM:
29016 case LEFT:
29017 case RIGHT:
29018 case BOTH:
29019 case EMPTY:
29020 case MULTISET:
29021 case SUBMULTISET:
29022 case LEADING:
29023 case TRAILING:
29024 case CHAR_CS:
29025 case NCHAR_CS:
29026 case DBTIMEZONE:
29027 case SESSIONTIMEZONE:
29028 case AUTHENTICATED:
29029 case LINK:
29030 case SHARED:
29031 case DIRECTORY:
29032 case USER:
29033 case IDENTIFIER:
29034 case QUOTED_LITERAL:
29035 case SQLDATA_CLASS:
29036 case CUSTOMDATUM_CLASS:
29037 case ORADATA_CLASS:
29038 case JAVA_INTERFACE_CLASS:
29039 ;
29040 break;
29041 default:
29042 jj_la1[441] = jj_gen;
29043 break label_101;
29044 }
29045 switch (jj_nt.kind) {
29046 case AFTER:
29047 case BEFORE:
29048 case INSTEADOF:
29049 TriggerTimingPointSection();
29050 break;
29051 case PRAGMA:
29052 Pragma();
29053 break;
29054 default:
29055 jj_la1[442] = jj_gen;
29056 if (jj_2_81(2)) {
29057 ExceptionDeclaration();
29058 } else if (jj_2_82(2)) {
29059 SubTypeDefinition();
29060 } else if (jj_2_83(4)) {
29061 VariableOrConstantDeclaration();
29062 } else if (jj_2_84(2)) {
29063 CursorSpecification();
29064 } else {
29065 switch (jj_nt.kind) {
29066 case CURSOR:
29067 CursorBody();
29068 break;
29069 case IDENTIFIER:
29070 CollectionDeclaration();
29071 break;
29072 case CREATE:
29073 case FUNCTION:
29074 case PROCEDURE:
29075 ProgramUnit();
29076 break;
29077 default:
29078 jj_la1[443] = jj_gen;
29079 jj_consume_token(-1);
29080 throw new ParseException();
29081 }
29082 }
29083 }
29084 }
29085 jj_consume_token(END);
29086 switch (jj_nt.kind) {
29087 case REPLACE:
29088 case DEFINER:
29089 case CURRENT_USER:
29090 case SERIALLY_REUSABLE:
29091 case RESTRICT_REFERENCES:
29092 case EXCEPTION_INIT:
29093 case AUTONOMOUS_TRANSACTION:
29094 case LANGUAGE:
29095 case INLINE:
29096 case ADD:
29097 case AGGREGATE:
29098 case ALL:
29099 case ALTER:
29100 case AND:
29101 case ANY:
29102 case ARRAY:
29103 case AS:
29104 case ASC:
29105 case AT:
29106 case ATTRIBUTE:
29107 case AUTHID:
29108 case AVG:
29109 case BETWEEN:
29110 case BINARY_INTEGER:
29111 case BODY:
29112 case BOOLEAN:
29113 case BULK:
29114 case BY:
29115 case BYTE:
29116 case CASCADE:
29117 case CASE:
29118 case CHAR:
29119 case CHAR_BASE:
29120 case CHECK:
29121 case CLOSE:
29122 case CLUSTER:
29123 case COALESCE:
29124 case COLLECT:
29125 case COLUMN:
29126 case COMMENT:
29127 case COMMIT:
29128 case COMPRESS:
29129 case CONNECT:
29130 case CONSTANT:
29131 case CONSTRUCTOR:
29132 case CONTINUE:
29133 case CONVERT:
29134 case CREATE:
29135 case CURRENT:
29136 case CURRVAL:
29137 case CURSOR:
29138 case DATA:
29139 case DATE:
29140 case DAY:
29141 case DECLARE:
29142 case DECIMAL:
29143 case _DEFAULT:
29144 case DELETE:
29145 case DESC:
29146 case DISABLE:
29147 case DISTINCT:
29148 case DO:
29149 case DROP:
29150 case EDITIONABLE:
29151 case ELEMENT:
29152 case ELSE:
29153 case ELSIF:
29154 case ENABLE:
29155 case ESCAPE:
29156 case EXCEPT:
29157 case EXCEPTION:
29158 case EXCEPTIONS:
29159 case EXCLUSIVE:
29160 case EXECUTE:
29161 case EXISTS:
29162 case EXIT:
29163 case EXTERNAL:
29164 case EXTENDS:
29165 case EXTRACT:
29166 case FALSE:
29167 case FETCH:
29168 case FINAL:
29169 case FLOAT:
29170 case FOR:
29171 case FORALL:
29172 case FORCE:
29173 case FROM:
29174 case FUNCTION:
29175 case GLOBAL:
29176 case GOTO:
29177 case GROUP:
29178 case HASH:
29179 case HAVING:
29180 case HEAP:
29181 case HOUR:
29182 case IF:
29183 case IMMEDIATE:
29184 case IN:
29185 case INDEX:
29186 case INDICES:
29187 case INDEXTYPE:
29188 case INDICATOR:
29189 case INSERT:
29190 case INSTANTIABLE:
29191 case INTEGER:
29192 case INTERFACE:
29193 case INTERSECT:
29194 case INTERVAL:
29195 case INTO:
29196 case INVALIDATE:
29197 case IS:
29198 case ISOLATION:
29199 case JAVA:
29200 case LEVEL:
29201 case LIKE:
29202 case LIMIT:
29203 case LIMITED:
29204 case LOCK:
29205 case LONG:
29206 case LOOP:
29207 case MAP:
29208 case MAX:
29209 case MEMBER:
29210 case MERGE:
29211 case MIN:
29212 case MINUS:
29213 case MINUTE:
29214 case MLSLABEL:
29215 case MODIFY:
29216 case MOD:
29217 case MODE:
29218 case MONTH:
29219 case NATURAL:
29220 case NATURALN:
29221 case NEW:
29222 case NEXTVAL:
29223 case NO:
29224 case NOCOPY:
29225 case NONEDITIONABLE:
29226 case NOT:
29227 case NOWAIT:
29228 case NULL:
29229 case NULLIF:
29230 case NUMBER:
29231 case BFILE_BASE:
29232 case BLOB_BASE:
29233 case CLOB_BASE:
29234 case DATE_BASE:
29235 case NUMBER_BASE:
29236 case OBJECT:
29237 case OCIROWID:
29238 case OF:
29239 case OID:
29240 case ON:
29241 case OPAQUE:
29242 case OPEN:
29243 case OPERATOR:
29244 case OPTION:
29245 case OR:
29246 case ORDER:
29247 case ORGANIZATION:
29248 case OTHERS:
29249 case OUT:
29250 case OVERRIDING:
29251 case PACKAGE:
29252 case PARTITION:
29253 case PCTFREE:
29254 case PLS_INTEGER:
29255 case POSITIVE:
29256 case POSITIVEN:
29257 case PRESERVE:
29258 case PRIOR:
29259 case PROMPT:
29260 case PRIVATE:
29261 case PROCEDURE:
29262 case PUBLIC:
29263 case RAISE:
29264 case RANGE:
29265 case RAW:
29266 case REAL:
29267 case RECORD:
29268 case REF:
29269 case RELEASE:
29270 case RELIES_ON:
29271 case RENAME:
29272 case RESULT:
29273 case RETURN:
29274 case RETURNING:
29275 case REVERSE:
29276 case ROLLBACK:
29277 case ROW:
29278 case ROWS:
29279 case ROWID:
29280 case ROWNUM:
29281 case ROWTYPE:
29282 case SAVE:
29283 case SAVEPOINT:
29284 case SECOND:
29285 case SELECT:
29286 case SELF:
29287 case SEPARATE:
29288 case SET:
29289 case SHARE:
29290 case SMALLINT:
29291 case SPACE:
29292 case SQL:
29293 case SQLCODE:
29294 case SQLERRM:
29295 case START:
29296 case STATIC:
29297 case STDDEV:
29298 case SUBTYPE:
29299 case SUBSTITUTABLE:
29300 case SUCCESSFUL:
29301 case SUM:
29302 case SYNONYM:
29303 case SYSDATE:
29304 case SYS_REFCURSOR:
29305 case TABLE:
29306 case TEMPORARY:
29307 case THEN:
29308 case TIME:
29309 case TIMESTAMP:
29310 case TIMEZONE_REGION:
29311 case TIMEZONE_ABBR:
29312 case TIMEZONE_MINUTE:
29313 case TIMEZONE_HOUR:
29314 case TO:
29315 case TRANSACTION:
29316 case TRIGGER:
29317 case TRUE:
29318 case TYPE:
29319 case UI:
29320 case UNDER:
29321 case USING:
29322 case WHILE:
29323 case YES:
29324 case SHOW:
29325 case A:
29326 case UPDATE:
29327 case VARCHAR:
29328 case VARCHAR2:
29329 case DOUBLE:
29330 case DEC:
29331 case PRECISION:
29332 case INT:
29333 case NUMERIC:
29334 case SIGNTYPE:
29335 case NCHAR:
29336 case NVARCHAR2:
29337 case STRING:
29338 case UROWID:
29339 case VARRAY:
29340 case VARYING:
29341 case BFILE:
29342 case BLOB:
29343 case CLOB:
29344 case NCLOB:
29345 case YEAR:
29346 case LOCAL:
29347 case WITH:
29348 case ZONE:
29349 case CHARACTER:
29350 case AFTER:
29351 case BEFORE:
29352 case OLD:
29353 case PARENT:
29354 case ANALYZE:
29355 case ASSOCIATE:
29356 case AUDIT:
29357 case COMPOUND:
29358 case DATABASE:
29359 case CALL:
29360 case DDL:
29361 case DISASSOCIATE:
29362 case EACH:
29363 case FOLLOWS:
29364 case LOGOFF:
29365 case LOGON:
29366 case NESTED:
29367 case NOAUDIT:
29368 case SCHEMA:
29369 case SERVERERROR:
29370 case SHUTDOWN:
29371 case STARTUP:
29372 case STATEMENT:
29373 case STATISTICS:
29374 case SUSPEND:
29375 case TRUNCATE:
29376 case WRAPPED:
29377 case LIBRARY:
29378 case NAME:
29379 case STRUCT:
29380 case CONTEXT:
29381 case PARAMETERS:
29382 case LENGTH:
29383 case TDO:
29384 case MAXLEN:
29385 case CHARSETID:
29386 case CHARSETFORM:
29387 case ACCEPT:
29388 case ACCESSIBLE:
29389 case COPY:
29390 case DEFINE:
29391 case DISCONNECT:
29392 case HOST:
29393 case PRINT:
29394 case QUIT:
29395 case REMARK:
29396 case UNDEFINE:
29397 case VARIABLE:
29398 case WHENEVER:
29399 case ATTACH:
29400 case CAST:
29401 case TREAT:
29402 case TRIM:
29403 case LEFT:
29404 case RIGHT:
29405 case BOTH:
29406 case EMPTY:
29407 case MULTISET:
29408 case SUBMULTISET:
29409 case LEADING:
29410 case TRAILING:
29411 case CHAR_CS:
29412 case NCHAR_CS:
29413 case DBTIMEZONE:
29414 case SESSIONTIMEZONE:
29415 case AUTHENTICATED:
29416 case LINK:
29417 case SHARED:
29418 case DIRECTORY:
29419 case USER:
29420 case IDENTIFIER:
29421 case QUOTED_LITERAL:
29422 case SQLDATA_CLASS:
29423 case CUSTOMDATUM_CLASS:
29424 case ORADATA_CLASS:
29425 case JAVA_INTERFACE_CLASS:
29426 ID();
29427 break;
29428 default:
29429 jj_la1[444] = jj_gen;
29430 ;
29431 }
29432 jj_consume_token(4);
29433 jjtree.closeNodeScope(jjtn000, true);
29434 jjtc000 = false;
29435 {if (true) return jjtn000 ;}
29436 } catch (Throwable jjte000) {
29437 if (jjtc000) {
29438 jjtree.clearNodeScope(jjtn000);
29439 jjtc000 = false;
29440 } else {
29441 jjtree.popNode();
29442 }
29443 if (jjte000 instanceof RuntimeException) {
29444 {if (true) throw (RuntimeException)jjte000;}
29445 }
29446 if (jjte000 instanceof ParseException) {
29447 {if (true) throw (ParseException)jjte000;}
29448 }
29449 {if (true) throw (Error)jjte000;}
29450 } finally {
29451 if (jjtc000) {
29452 jjtree.closeNodeScope(jjtn000, true);
29453 }
29454 }
29455 throw new Error("Missing return statement in function");
29456 }
29457
29458
29459
29460
29461
29462
29463
29464
29465 final public ASTNonDMLTrigger NonDMLTrigger() throws ParseException {
29466
29467 ASTNonDMLTrigger jjtn000 = new ASTNonDMLTrigger(this, JJTNONDMLTRIGGER);
29468 boolean jjtc000 = true;
29469 jjtree.openNodeScope(jjtn000);
29470 try {
29471 switch (jj_nt.kind) {
29472 case BEFORE:
29473 jj_consume_token(BEFORE);
29474 break;
29475 case AFTER:
29476 jj_consume_token(AFTER);
29477 break;
29478 default:
29479 jj_la1[445] = jj_gen;
29480 jj_consume_token(-1);
29481 throw new ParseException();
29482 }
29483 switch (jj_nt.kind) {
29484 case ALTER:
29485 case COMMENT:
29486 case CREATE:
29487 case DROP:
29488 case GRANT:
29489 case RENAME:
29490 case REVOKE:
29491 case ANALYZE:
29492 case ASSOCIATE:
29493 case AUDIT:
29494 case DDL:
29495 case DISASSOCIATE:
29496 case NOAUDIT:
29497 case TRUNCATE:
29498 DDLEvent();
29499 break;
29500 case LOGOFF:
29501 case LOGON:
29502 case SERVERERROR:
29503 case SHUTDOWN:
29504 case STARTUP:
29505 case SUSPEND:
29506 DatabaseEvent();
29507 break;
29508 default:
29509 jj_la1[446] = jj_gen;
29510 jj_consume_token(-1);
29511 throw new ParseException();
29512 }
29513 label_102:
29514 while (true) {
29515 switch (jj_nt.kind) {
29516 case OR:
29517 ;
29518 break;
29519 default:
29520 jj_la1[447] = jj_gen;
29521 break label_102;
29522 }
29523 jj_consume_token(OR);
29524 switch (jj_nt.kind) {
29525 case ALTER:
29526 case COMMENT:
29527 case CREATE:
29528 case DROP:
29529 case GRANT:
29530 case RENAME:
29531 case REVOKE:
29532 case ANALYZE:
29533 case ASSOCIATE:
29534 case AUDIT:
29535 case DDL:
29536 case DISASSOCIATE:
29537 case NOAUDIT:
29538 case TRUNCATE:
29539 DDLEvent();
29540 break;
29541 case LOGOFF:
29542 case LOGON:
29543 case SERVERERROR:
29544 case SHUTDOWN:
29545 case STARTUP:
29546 case SUSPEND:
29547 DatabaseEvent();
29548 break;
29549 default:
29550 jj_la1[448] = jj_gen;
29551 jj_consume_token(-1);
29552 throw new ParseException();
29553 }
29554 }
29555 jj_consume_token(ON);
29556 switch (jj_nt.kind) {
29557 case DATABASE:
29558 jj_consume_token(DATABASE);
29559 break;
29560 case REPLACE:
29561 case DEFINER:
29562 case CURRENT_USER:
29563 case SERIALLY_REUSABLE:
29564 case RESTRICT_REFERENCES:
29565 case EXCEPTION_INIT:
29566 case AUTONOMOUS_TRANSACTION:
29567 case LANGUAGE:
29568 case INLINE:
29569 case ADD:
29570 case AGGREGATE:
29571 case ALL:
29572 case ALTER:
29573 case AND:
29574 case ANY:
29575 case ARRAY:
29576 case AS:
29577 case ASC:
29578 case AT:
29579 case ATTRIBUTE:
29580 case AUTHID:
29581 case AVG:
29582 case BETWEEN:
29583 case BINARY_INTEGER:
29584 case BODY:
29585 case BOOLEAN:
29586 case BULK:
29587 case BY:
29588 case BYTE:
29589 case CASCADE:
29590 case CASE:
29591 case CHAR:
29592 case CHAR_BASE:
29593 case CHECK:
29594 case CLOSE:
29595 case CLUSTER:
29596 case COALESCE:
29597 case COLLECT:
29598 case COLUMN:
29599 case COMMENT:
29600 case COMMIT:
29601 case COMPRESS:
29602 case CONNECT:
29603 case CONSTANT:
29604 case CONSTRUCTOR:
29605 case CONTINUE:
29606 case CONVERT:
29607 case CREATE:
29608 case CURRENT:
29609 case CURRVAL:
29610 case CURSOR:
29611 case DATA:
29612 case DATE:
29613 case DAY:
29614 case DECLARE:
29615 case DECIMAL:
29616 case _DEFAULT:
29617 case DELETE:
29618 case DESC:
29619 case DISABLE:
29620 case DISTINCT:
29621 case DO:
29622 case DROP:
29623 case EDITIONABLE:
29624 case ELEMENT:
29625 case ELSE:
29626 case ELSIF:
29627 case ENABLE:
29628 case ESCAPE:
29629 case EXCEPT:
29630 case EXCEPTION:
29631 case EXCEPTIONS:
29632 case EXCLUSIVE:
29633 case EXECUTE:
29634 case EXISTS:
29635 case EXIT:
29636 case EXTERNAL:
29637 case EXTENDS:
29638 case EXTRACT:
29639 case FALSE:
29640 case FETCH:
29641 case FINAL:
29642 case FLOAT:
29643 case FOR:
29644 case FORALL:
29645 case FORCE:
29646 case FROM:
29647 case FUNCTION:
29648 case GLOBAL:
29649 case GOTO:
29650 case GROUP:
29651 case HASH:
29652 case HAVING:
29653 case HEAP:
29654 case HOUR:
29655 case IF:
29656 case IMMEDIATE:
29657 case IN:
29658 case INDEX:
29659 case INDICES:
29660 case INDEXTYPE:
29661 case INDICATOR:
29662 case INSERT:
29663 case INSTANTIABLE:
29664 case INTEGER:
29665 case INTERFACE:
29666 case INTERSECT:
29667 case INTERVAL:
29668 case INTO:
29669 case INVALIDATE:
29670 case IS:
29671 case ISOLATION:
29672 case JAVA:
29673 case LEVEL:
29674 case LIKE:
29675 case LIMIT:
29676 case LIMITED:
29677 case LOCK:
29678 case LONG:
29679 case LOOP:
29680 case MAP:
29681 case MAX:
29682 case MEMBER:
29683 case MERGE:
29684 case MIN:
29685 case MINUS:
29686 case MINUTE:
29687 case MLSLABEL:
29688 case MODIFY:
29689 case MOD:
29690 case MODE:
29691 case MONTH:
29692 case NATURAL:
29693 case NATURALN:
29694 case NEW:
29695 case NEXTVAL:
29696 case NO:
29697 case NOCOPY:
29698 case NONEDITIONABLE:
29699 case NOT:
29700 case NOWAIT:
29701 case NULL:
29702 case NULLIF:
29703 case NUMBER:
29704 case BFILE_BASE:
29705 case BLOB_BASE:
29706 case CLOB_BASE:
29707 case DATE_BASE:
29708 case NUMBER_BASE:
29709 case OBJECT:
29710 case OCIROWID:
29711 case OF:
29712 case OID:
29713 case ON:
29714 case OPAQUE:
29715 case OPEN:
29716 case OPERATOR:
29717 case OPTION:
29718 case OR:
29719 case ORDER:
29720 case ORGANIZATION:
29721 case OTHERS:
29722 case OUT:
29723 case OVERRIDING:
29724 case PACKAGE:
29725 case PARTITION:
29726 case PCTFREE:
29727 case PLS_INTEGER:
29728 case POSITIVE:
29729 case POSITIVEN:
29730 case PRESERVE:
29731 case PRIOR:
29732 case PROMPT:
29733 case PRIVATE:
29734 case PROCEDURE:
29735 case PUBLIC:
29736 case RAISE:
29737 case RANGE:
29738 case RAW:
29739 case REAL:
29740 case RECORD:
29741 case REF:
29742 case RELEASE:
29743 case RELIES_ON:
29744 case RENAME:
29745 case RESULT:
29746 case RETURN:
29747 case RETURNING:
29748 case REVERSE:
29749 case ROLLBACK:
29750 case ROW:
29751 case ROWS:
29752 case ROWID:
29753 case ROWNUM:
29754 case ROWTYPE:
29755 case SAVE:
29756 case SAVEPOINT:
29757 case SECOND:
29758 case SELECT:
29759 case SELF:
29760 case SEPARATE:
29761 case SET:
29762 case SHARE:
29763 case SMALLINT:
29764 case SPACE:
29765 case SQL:
29766 case SQLCODE:
29767 case SQLERRM:
29768 case START:
29769 case STATIC:
29770 case STDDEV:
29771 case SUBTYPE:
29772 case SUBSTITUTABLE:
29773 case SUCCESSFUL:
29774 case SUM:
29775 case SYNONYM:
29776 case SYSDATE:
29777 case SYS_REFCURSOR:
29778 case TABLE:
29779 case TEMPORARY:
29780 case THEN:
29781 case TIME:
29782 case TIMESTAMP:
29783 case TIMEZONE_REGION:
29784 case TIMEZONE_ABBR:
29785 case TIMEZONE_MINUTE:
29786 case TIMEZONE_HOUR:
29787 case TO:
29788 case TRANSACTION:
29789 case TRIGGER:
29790 case TRUE:
29791 case TYPE:
29792 case UI:
29793 case UNDER:
29794 case USING:
29795 case WHILE:
29796 case YES:
29797 case SHOW:
29798 case A:
29799 case UPDATE:
29800 case VARCHAR:
29801 case VARCHAR2:
29802 case DOUBLE:
29803 case DEC:
29804 case PRECISION:
29805 case INT:
29806 case NUMERIC:
29807 case SIGNTYPE:
29808 case NCHAR:
29809 case NVARCHAR2:
29810 case STRING:
29811 case UROWID:
29812 case VARRAY:
29813 case VARYING:
29814 case BFILE:
29815 case BLOB:
29816 case CLOB:
29817 case NCLOB:
29818 case YEAR:
29819 case LOCAL:
29820 case WITH:
29821 case ZONE:
29822 case CHARACTER:
29823 case AFTER:
29824 case BEFORE:
29825 case OLD:
29826 case PARENT:
29827 case ANALYZE:
29828 case ASSOCIATE:
29829 case AUDIT:
29830 case COMPOUND:
29831 case CALL:
29832 case DDL:
29833 case DISASSOCIATE:
29834 case EACH:
29835 case FOLLOWS:
29836 case LOGOFF:
29837 case LOGON:
29838 case NESTED:
29839 case NOAUDIT:
29840 case SCHEMA:
29841 case SERVERERROR:
29842 case SHUTDOWN:
29843 case STARTUP:
29844 case STATEMENT:
29845 case STATISTICS:
29846 case SUSPEND:
29847 case TRUNCATE:
29848 case WRAPPED:
29849 case LIBRARY:
29850 case NAME:
29851 case STRUCT:
29852 case CONTEXT:
29853 case PARAMETERS:
29854 case LENGTH:
29855 case TDO:
29856 case MAXLEN:
29857 case CHARSETID:
29858 case CHARSETFORM:
29859 case ACCEPT:
29860 case ACCESSIBLE:
29861 case COPY:
29862 case DEFINE:
29863 case DISCONNECT:
29864 case HOST:
29865 case PRINT:
29866 case QUIT:
29867 case REMARK:
29868 case UNDEFINE:
29869 case VARIABLE:
29870 case WHENEVER:
29871 case ATTACH:
29872 case CAST:
29873 case TREAT:
29874 case TRIM:
29875 case LEFT:
29876 case RIGHT:
29877 case BOTH:
29878 case EMPTY:
29879 case MULTISET:
29880 case SUBMULTISET:
29881 case LEADING:
29882 case TRAILING:
29883 case CHAR_CS:
29884 case NCHAR_CS:
29885 case DBTIMEZONE:
29886 case SESSIONTIMEZONE:
29887 case AUTHENTICATED:
29888 case LINK:
29889 case SHARED:
29890 case DIRECTORY:
29891 case USER:
29892 case IDENTIFIER:
29893 case QUOTED_LITERAL:
29894 case SQLDATA_CLASS:
29895 case CUSTOMDATUM_CLASS:
29896 case ORADATA_CLASS:
29897 case JAVA_INTERFACE_CLASS:
29898 if (jj_2_85(2)) {
29899 ID();
29900 jj_consume_token(3);
29901 } else {
29902 ;
29903 }
29904 jj_consume_token(SCHEMA);
29905 break;
29906 default:
29907 jj_la1[449] = jj_gen;
29908 jj_consume_token(-1);
29909 throw new ParseException();
29910 }
29911 jjtree.closeNodeScope(jjtn000, true);
29912 jjtc000 = false;
29913 {if (true) return jjtn000 ;}
29914 } catch (Throwable jjte000) {
29915 if (jjtc000) {
29916 jjtree.clearNodeScope(jjtn000);
29917 jjtc000 = false;
29918 } else {
29919 jjtree.popNode();
29920 }
29921 if (jjte000 instanceof RuntimeException) {
29922 {if (true) throw (RuntimeException)jjte000;}
29923 }
29924 if (jjte000 instanceof ParseException) {
29925 {if (true) throw (ParseException)jjte000;}
29926 }
29927 {if (true) throw (Error)jjte000;}
29928 } finally {
29929 if (jjtc000) {
29930 jjtree.closeNodeScope(jjtn000, true);
29931 }
29932 }
29933 throw new Error("Missing return statement in function");
29934 }
29935
29936 final public ASTDDLEvent DDLEvent() throws ParseException {
29937
29938 ASTDDLEvent jjtn000 = new ASTDDLEvent(this, JJTDDLEVENT);
29939 boolean jjtc000 = true;
29940 jjtree.openNodeScope(jjtn000);
29941 try {
29942 switch (jj_nt.kind) {
29943 case ALTER:
29944 jj_consume_token(ALTER);
29945 break;
29946 case ANALYZE:
29947 jj_consume_token(ANALYZE);
29948 break;
29949 case ASSOCIATE:
29950 jj_consume_token(ASSOCIATE);
29951 jj_consume_token(STATISTICS);
29952 break;
29953 case AUDIT:
29954 jj_consume_token(AUDIT);
29955 break;
29956 case COMMENT:
29957 jj_consume_token(COMMENT);
29958 break;
29959 case CREATE:
29960 jj_consume_token(CREATE);
29961 break;
29962 case DISASSOCIATE:
29963 jj_consume_token(DISASSOCIATE);
29964 jj_consume_token(STATISTICS);
29965 break;
29966 case DROP:
29967 jj_consume_token(DROP);
29968 break;
29969 case GRANT:
29970 jj_consume_token(GRANT);
29971 break;
29972 case NOAUDIT:
29973 jj_consume_token(NOAUDIT);
29974 break;
29975 case RENAME:
29976 jj_consume_token(RENAME);
29977 break;
29978 case REVOKE:
29979 jj_consume_token(REVOKE);
29980 break;
29981 case TRUNCATE:
29982 jj_consume_token(TRUNCATE);
29983 break;
29984 case DDL:
29985 jj_consume_token(DDL);
29986 break;
29987 default:
29988 jj_la1[450] = jj_gen;
29989 jj_consume_token(-1);
29990 throw new ParseException();
29991 }
29992 jjtree.closeNodeScope(jjtn000, true);
29993 jjtc000 = false;
29994 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29995 } finally {
29996 if (jjtc000) {
29997 jjtree.closeNodeScope(jjtn000, true);
29998 }
29999 }
30000 throw new Error("Missing return statement in function");
30001 }
30002
30003 final public ASTDatabaseEvent DatabaseEvent() throws ParseException {
30004
30005 ASTDatabaseEvent jjtn000 = new ASTDatabaseEvent(this, JJTDATABASEEVENT);
30006 boolean jjtc000 = true;
30007 jjtree.openNodeScope(jjtn000);
30008 try {
30009 switch (jj_nt.kind) {
30010 case STARTUP:
30011 jj_consume_token(STARTUP);
30012 break;
30013 case SHUTDOWN:
30014 jj_consume_token(SHUTDOWN);
30015 break;
30016 case LOGON:
30017 jj_consume_token(LOGON);
30018 break;
30019 case LOGOFF:
30020 jj_consume_token(LOGOFF);
30021 break;
30022 case SERVERERROR:
30023 jj_consume_token(SERVERERROR);
30024 break;
30025 case SUSPEND:
30026 jj_consume_token(SUSPEND);
30027 break;
30028 default:
30029 jj_la1[451] = jj_gen;
30030 jj_consume_token(-1);
30031 throw new ParseException();
30032 }
30033 jjtree.closeNodeScope(jjtn000, true);
30034 jjtc000 = false;
30035 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30036 } finally {
30037 if (jjtc000) {
30038 jjtree.closeNodeScope(jjtn000, true);
30039 }
30040 }
30041 throw new Error("Missing return statement in function");
30042 }
30043
30044 final public ASTNonDMLEvent NonDMLEvent() throws ParseException {
30045
30046 ASTNonDMLEvent jjtn000 = new ASTNonDMLEvent(this, JJTNONDMLEVENT);
30047 boolean jjtc000 = true;
30048 jjtree.openNodeScope(jjtn000);
30049 try {
30050 switch (jj_nt.kind) {
30051 case ALTER:
30052 case COMMENT:
30053 case CREATE:
30054 case DROP:
30055 case GRANT:
30056 case RENAME:
30057 case REVOKE:
30058 case ANALYZE:
30059 case ASSOCIATE:
30060 case AUDIT:
30061 case DDL:
30062 case DISASSOCIATE:
30063 case NOAUDIT:
30064 case TRUNCATE:
30065 DDLEvent();
30066 break;
30067 case LOGOFF:
30068 case LOGON:
30069 case SERVERERROR:
30070 case SHUTDOWN:
30071 case STARTUP:
30072 case SUSPEND:
30073 DatabaseEvent();
30074 break;
30075 default:
30076 jj_la1[452] = jj_gen;
30077 jj_consume_token(-1);
30078 throw new ParseException();
30079 }
30080 jjtree.closeNodeScope(jjtn000, true);
30081 jjtc000 = false;
30082 {if (true) return jjtn000;}
30083 } catch (Throwable jjte000) {
30084 if (jjtc000) {
30085 jjtree.clearNodeScope(jjtn000);
30086 jjtc000 = false;
30087 } else {
30088 jjtree.popNode();
30089 }
30090 if (jjte000 instanceof RuntimeException) {
30091 {if (true) throw (RuntimeException)jjte000;}
30092 }
30093 if (jjte000 instanceof ParseException) {
30094 {if (true) throw (ParseException)jjte000;}
30095 }
30096 {if (true) throw (Error)jjte000;}
30097 } finally {
30098 if (jjtc000) {
30099 jjtree.closeNodeScope(jjtn000, true);
30100 }
30101 }
30102 throw new Error("Missing return statement in function");
30103 }
30104
30105
30106
30107
30108
30109
30110
30111
30112 final public void AlterTrigger() throws ParseException {
30113
30114 ASTAlterTrigger jjtn000 = new ASTAlterTrigger(this, JJTALTERTRIGGER);
30115 boolean jjtc000 = true;
30116 jjtree.openNodeScope(jjtn000);
30117 try {
30118 jj_consume_token(ALTER);
30119 jj_consume_token(TRIGGER);
30120 Skip2NextTerminator(null,";");
30121 jj_consume_token(4);
30122 jjtree.closeNodeScope(jjtn000, true);
30123 jjtc000 = false;
30124 {if (true) return;}
30125 } catch (Throwable jjte000) {
30126 if (jjtc000) {
30127 jjtree.clearNodeScope(jjtn000);
30128 jjtc000 = false;
30129 } else {
30130 jjtree.popNode();
30131 }
30132 if (jjte000 instanceof RuntimeException) {
30133 {if (true) throw (RuntimeException)jjte000;}
30134 }
30135 if (jjte000 instanceof ParseException) {
30136 {if (true) throw (ParseException)jjte000;}
30137 }
30138 {if (true) throw (Error)jjte000;}
30139 } finally {
30140 if (jjtc000) {
30141 jjtree.closeNodeScope(jjtn000, true);
30142 }
30143 }
30144 }
30145
30146
30147 final public ASTKEYWORD_RESERVED KEYWORD_RESERVED() throws ParseException {
30148
30149 ASTKEYWORD_RESERVED jjtn000 = new ASTKEYWORD_RESERVED(this, JJTKEYWORD_RESERVED);
30150 boolean jjtc000 = true;
30151 jjtree.openNodeScope(jjtn000);
30152 try {
30153 switch (jj_nt.kind) {
30154 case ALL:
30155 jj_consume_token(ALL);
30156 break;
30157 case ALTER:
30158 jj_consume_token(ALTER);
30159 break;
30160 case AND:
30161 jj_consume_token(AND);
30162 break;
30163 case ANY:
30164 jj_consume_token(ANY);
30165 break;
30166 case AS:
30167 jj_consume_token(AS);
30168 break;
30169 case ASC:
30170 jj_consume_token(ASC);
30171 break;
30172 case BETWEEN:
30173 jj_consume_token(BETWEEN);
30174 break;
30175 case BY:
30176 jj_consume_token(BY);
30177 break;
30178 case CHAR:
30179 jj_consume_token(CHAR);
30180 break;
30181 case CHECK:
30182 jj_consume_token(CHECK);
30183 break;
30184 case CLUSTER:
30185 jj_consume_token(CLUSTER);
30186 break;
30187 case COMPRESS:
30188 jj_consume_token(COMPRESS);
30189 break;
30190 case CONNECT:
30191 jj_consume_token(CONNECT);
30192 break;
30193 case CREATE:
30194 jj_consume_token(CREATE);
30195 break;
30196 case DATE:
30197 jj_consume_token(DATE);
30198 break;
30199 case DECIMAL:
30200 jj_consume_token(DECIMAL);
30201 break;
30202 case _DEFAULT:
30203 jj_consume_token(_DEFAULT);
30204 break;
30205 case DELETE:
30206 jj_consume_token(DELETE);
30207 break;
30208 case DESC:
30209 jj_consume_token(DESC);
30210 break;
30211 case DISTINCT:
30212 jj_consume_token(DISTINCT);
30213 break;
30214 case DROP:
30215 jj_consume_token(DROP);
30216 break;
30217 case ELSE:
30218 jj_consume_token(ELSE);
30219 break;
30220 case EXCLUSIVE:
30221 jj_consume_token(EXCLUSIVE);
30222 break;
30223 case EXISTS:
30224 jj_consume_token(EXISTS);
30225 break;
30226 case FLOAT:
30227 jj_consume_token(FLOAT);
30228 break;
30229 case FOR:
30230 jj_consume_token(FOR);
30231 break;
30232 case FROM:
30233 jj_consume_token(FROM);
30234 break;
30235 case GRANT:
30236 jj_consume_token(GRANT);
30237 break;
30238 case GROUP:
30239 jj_consume_token(GROUP);
30240 break;
30241 case HAVING:
30242 jj_consume_token(HAVING);
30243 break;
30244 case IDENTIFIED:
30245 jj_consume_token(IDENTIFIED);
30246 break;
30247 case IN:
30248 jj_consume_token(IN);
30249 break;
30250 case INDEX:
30251 jj_consume_token(INDEX);
30252 break;
30253 case INSERT:
30254 jj_consume_token(INSERT);
30255 break;
30256 case INTEGER:
30257 jj_consume_token(INTEGER);
30258 break;
30259 case INTERSECT:
30260 jj_consume_token(INTERSECT);
30261 break;
30262 case INTO:
30263 jj_consume_token(INTO);
30264 break;
30265 case IS:
30266 jj_consume_token(IS);
30267 break;
30268 case LIKE:
30269 jj_consume_token(LIKE);
30270 break;
30271 case LOCK:
30272 jj_consume_token(LOCK);
30273 break;
30274 case LONG:
30275 jj_consume_token(LONG);
30276 break;
30277 case MINUS:
30278 jj_consume_token(MINUS);
30279 break;
30280 case MODE:
30281 jj_consume_token(MODE);
30282 break;
30283 case NOCOMPRESS:
30284 jj_consume_token(NOCOMPRESS);
30285 break;
30286 case NOT:
30287 jj_consume_token(NOT);
30288 break;
30289 case NOWAIT:
30290 jj_consume_token(NOWAIT);
30291 break;
30292 case NULL:
30293 jj_consume_token(NULL);
30294 break;
30295 case NUMBER:
30296 jj_consume_token(NUMBER);
30297 break;
30298 case OF:
30299 jj_consume_token(OF);
30300 break;
30301 case ON:
30302 jj_consume_token(ON);
30303 break;
30304 case OPTION:
30305 jj_consume_token(OPTION);
30306 break;
30307 case OR:
30308 jj_consume_token(OR);
30309 break;
30310 case ORDER:
30311 jj_consume_token(ORDER);
30312 break;
30313 case PCTFREE:
30314 jj_consume_token(PCTFREE);
30315 break;
30316 case PRIOR:
30317 jj_consume_token(PRIOR);
30318 break;
30319 case PUBLIC:
30320 jj_consume_token(PUBLIC);
30321 break;
30322 case RAW:
30323 jj_consume_token(RAW);
30324 break;
30325 case RESOURCE:
30326 jj_consume_token(RESOURCE);
30327 break;
30328 case REVOKE:
30329 jj_consume_token(REVOKE);
30330 break;
30331 case SELECT:
30332 jj_consume_token(SELECT);
30333 break;
30334 case SET:
30335 jj_consume_token(SET);
30336 break;
30337 case SHARE:
30338 jj_consume_token(SHARE);
30339 break;
30340 case SIZE:
30341 jj_consume_token(SIZE);
30342 break;
30343 case SMALLINT:
30344 jj_consume_token(SMALLINT);
30345 break;
30346 case START:
30347 jj_consume_token(START);
30348 break;
30349 case SYNONYM:
30350 jj_consume_token(SYNONYM);
30351 break;
30352 case TABLE:
30353 jj_consume_token(TABLE);
30354 break;
30355 case THEN:
30356 jj_consume_token(THEN);
30357 break;
30358 case TO:
30359 jj_consume_token(TO);
30360 break;
30361 case TRIGGER:
30362 jj_consume_token(TRIGGER);
30363 break;
30364 case UNION:
30365 jj_consume_token(UNION);
30366 break;
30367 case UNIQUE:
30368 jj_consume_token(UNIQUE);
30369 break;
30370 case UPDATE:
30371 jj_consume_token(UPDATE);
30372 break;
30373 case VALUES:
30374 jj_consume_token(VALUES);
30375 break;
30376 case VARCHAR:
30377 jj_consume_token(VARCHAR);
30378 break;
30379 case VARCHAR2:
30380 jj_consume_token(VARCHAR2);
30381 break;
30382 case VIEW:
30383 jj_consume_token(VIEW);
30384 break;
30385 case WHERE:
30386 jj_consume_token(WHERE);
30387 break;
30388 case WITH:
30389 jj_consume_token(WITH);
30390 break;
30391 default:
30392 jj_la1[453] = jj_gen;
30393 jj_consume_token(-1);
30394 throw new ParseException();
30395 }
30396 jjtree.closeNodeScope(jjtn000, true);
30397 jjtc000 = false;
30398 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30399 } finally {
30400 if (jjtc000) {
30401 jjtree.closeNodeScope(jjtn000, true);
30402 }
30403 }
30404 throw new Error("Missing return statement in function");
30405 }
30406
30407 final public ASTKEYWORD_UNRESERVED KEYWORD_UNRESERVED() throws ParseException {
30408
30409 ASTKEYWORD_UNRESERVED jjtn000 = new ASTKEYWORD_UNRESERVED(this, JJTKEYWORD_UNRESERVED);
30410 boolean jjtc000 = true;
30411 jjtree.openNodeScope(jjtn000);
30412 try {
30413 switch (jj_nt.kind) {
30414 case FALSE:
30415 jj_consume_token(FALSE);
30416 break;
30417 case TRUE:
30418 jj_consume_token(TRUE);
30419 break;
30420 case A:
30421 jj_consume_token(A);
30422 break;
30423 case ACCEPT:
30424 jj_consume_token(ACCEPT);
30425 break;
30426 case ADD:
30427 jj_consume_token(ADD);
30428 break;
30429 case AFTER:
30430 jj_consume_token(AFTER);
30431 break;
30432 case AGGREGATE:
30433 jj_consume_token(AGGREGATE);
30434 break;
30435 case ANALYZE:
30436 jj_consume_token(ANALYZE);
30437 break;
30438 case ASSOCIATE:
30439 jj_consume_token(ASSOCIATE);
30440 break;
30441 case AT:
30442 jj_consume_token(AT);
30443 break;
30444 case ATTACH:
30445 jj_consume_token(ATTACH);
30446 break;
30447 case ATTRIBUTE:
30448 jj_consume_token(ATTRIBUTE);
30449 break;
30450 case AUDIT:
30451 jj_consume_token(AUDIT);
30452 break;
30453 case AUTHENTICATED:
30454 jj_consume_token(AUTHENTICATED);
30455 break;
30456 case AUTHID:
30457 jj_consume_token(AUTHID);
30458 break;
30459 case BEFORE:
30460 jj_consume_token(BEFORE);
30461 break;
30462 case BFILE:
30463 jj_consume_token(BFILE);
30464 break;
30465 case BLOB:
30466 jj_consume_token(BLOB);
30467 break;
30468 case BOTH:
30469 jj_consume_token(BOTH);
30470 break;
30471 case BULK:
30472 jj_consume_token(BULK);
30473 break;
30474 case BYTE:
30475 jj_consume_token(BYTE);
30476 break;
30477 case CALL:
30478 jj_consume_token(CALL);
30479 break;
30480 case CASCADE:
30481 jj_consume_token(CASCADE);
30482 break;
30483 case CAST:
30484 jj_consume_token(CAST);
30485 break;
30486 case CHAR_CS:
30487 jj_consume_token(CHAR_CS);
30488 break;
30489 case CHARACTER:
30490 jj_consume_token(CHARACTER);
30491 break;
30492 case CHARSETFORM:
30493 jj_consume_token(CHARSETFORM);
30494 break;
30495 case CHARSETID:
30496 jj_consume_token(CHARSETID);
30497 break;
30498 case CLOB:
30499 jj_consume_token(CLOB);
30500 break;
30501 case CLOSE:
30502 jj_consume_token(CLOSE);
30503 break;
30504 case COALESCE:
30505 jj_consume_token(COALESCE);
30506 break;
30507 case COLLECT:
30508 jj_consume_token(COLLECT);
30509 break;
30510 case COLUMN:
30511 jj_consume_token(COLUMN);
30512 break;
30513 case COMMENT:
30514 jj_consume_token(COMMENT);
30515 break;
30516 case COMMIT:
30517 jj_consume_token(COMMIT);
30518 break;
30519 case COMPOUND:
30520 jj_consume_token(COMPOUND);
30521 break;
30522 case CONSTRUCTOR:
30523 jj_consume_token(CONSTRUCTOR);
30524 break;
30525 case CONTEXT:
30526 jj_consume_token(CONTEXT);
30527 break;
30528 case CONTINUE:
30529 jj_consume_token(CONTINUE);
30530 break;
30531 case CONVERT:
30532 jj_consume_token(CONVERT);
30533 break;
30534 case COPY:
30535 jj_consume_token(COPY);
30536 break;
30537 case CURRENT:
30538 jj_consume_token(CURRENT);
30539 break;
30540 case CURRENT_USER:
30541 jj_consume_token(CURRENT_USER);
30542 break;
30543 case CURSOR:
30544 jj_consume_token(CURSOR);
30545 break;
30546 case DATA:
30547 jj_consume_token(DATA);
30548 break;
30549 case DATABASE:
30550 jj_consume_token(DATABASE);
30551 break;
30552 case DAY:
30553 jj_consume_token(DAY);
30554 break;
30555 case DBTIMEZONE:
30556 jj_consume_token(DBTIMEZONE);
30557 break;
30558 case DDL:
30559 jj_consume_token(DDL);
30560 break;
30561 case DEC:
30562 jj_consume_token(DEC);
30563 break;
30564 case DEFINE:
30565 jj_consume_token(DEFINE);
30566 break;
30567 case DEFINER:
30568 jj_consume_token(DEFINER);
30569 break;
30570 case DIRECTORY:
30571 jj_consume_token(DIRECTORY);
30572 break;
30573 case DISABLE:
30574 jj_consume_token(DISABLE);
30575 break;
30576 case DISASSOCIATE:
30577 jj_consume_token(DISASSOCIATE);
30578 break;
30579 case DISCONNECT:
30580 jj_consume_token(DISCONNECT);
30581 break;
30582 case DOUBLE:
30583 jj_consume_token(DOUBLE);
30584 break;
30585 case EACH:
30586 jj_consume_token(EACH);
30587 break;
30588 case ELEMENT:
30589 jj_consume_token(ELEMENT);
30590 break;
30591 case EMPTY:
30592 jj_consume_token(EMPTY);
30593 break;
30594 case ENABLE:
30595 jj_consume_token(ENABLE);
30596 break;
30597 case ESCAPE:
30598 jj_consume_token(ESCAPE);
30599 break;
30600 case EXCEPT:
30601 jj_consume_token(EXCEPT);
30602 break;
30603 case EXCEPTIONS:
30604 jj_consume_token(EXCEPTIONS);
30605 break;
30606 case EXIT:
30607 jj_consume_token(EXIT);
30608 break;
30609 case EXTENDS:
30610 jj_consume_token(EXTENDS);
30611 break;
30612 case EXTERNAL:
30613 jj_consume_token(EXTERNAL);
30614 break;
30615 case EXTRACT:
30616 jj_consume_token(EXTRACT);
30617 break;
30618 case FINAL:
30619 jj_consume_token(FINAL);
30620 break;
30621 case FOLLOWS:
30622 jj_consume_token(FOLLOWS);
30623 break;
30624 case FORCE:
30625 jj_consume_token(FORCE);
30626 break;
30627 case FUNCTION:
30628 jj_consume_token(FUNCTION);
30629 break;
30630 case GLOBAL:
30631 jj_consume_token(GLOBAL);
30632 break;
30633 case HASH:
30634 jj_consume_token(HASH);
30635 break;
30636 case HEAP:
30637 jj_consume_token(HEAP);
30638 break;
30639 case HOST:
30640 jj_consume_token(HOST);
30641 break;
30642 case HOUR:
30643 jj_consume_token(HOUR);
30644 break;
30645 case IMMEDIATE:
30646 jj_consume_token(IMMEDIATE);
30647 break;
30648 case INDEXTYPE:
30649 jj_consume_token(INDEXTYPE);
30650 break;
30651 case INDICATOR:
30652 jj_consume_token(INDICATOR);
30653 break;
30654 case INDICES:
30655 jj_consume_token(INDICES);
30656 break;
30657 case INSTANTIABLE:
30658 jj_consume_token(INSTANTIABLE);
30659 break;
30660 case INTERVAL:
30661 jj_consume_token(INTERVAL);
30662 break;
30663 case INVALIDATE:
30664 jj_consume_token(INVALIDATE);
30665 break;
30666 case ISOLATION:
30667 jj_consume_token(ISOLATION);
30668 break;
30669 case JAVA:
30670 jj_consume_token(JAVA);
30671 break;
30672 case LANGUAGE:
30673 jj_consume_token(LANGUAGE);
30674 break;
30675 case LEADING:
30676 jj_consume_token(LEADING);
30677 break;
30678 case LEFT:
30679 jj_consume_token(LEFT);
30680 break;
30681 case LENGTH:
30682 jj_consume_token(LENGTH);
30683 break;
30684 case LEVEL:
30685 jj_consume_token(LEVEL);
30686 break;
30687 case LIBRARY:
30688 jj_consume_token(LIBRARY);
30689 break;
30690 case LIMIT:
30691 jj_consume_token(LIMIT);
30692 break;
30693 case LINK:
30694 jj_consume_token(LINK);
30695 break;
30696 case LOCAL:
30697 jj_consume_token(LOCAL);
30698 break;
30699 case LOGOFF:
30700 jj_consume_token(LOGOFF);
30701 break;
30702 case LOGON:
30703 jj_consume_token(LOGON);
30704 break;
30705 case MAP:
30706 jj_consume_token(MAP);
30707 break;
30708 case MAX:
30709 jj_consume_token(MAX);
30710 break;
30711 case MAXLEN:
30712 jj_consume_token(MAXLEN);
30713 break;
30714 case MEMBER:
30715 jj_consume_token(MEMBER);
30716 break;
30717 case MERGE:
30718 jj_consume_token(MERGE);
30719 break;
30720 case MIN:
30721 jj_consume_token(MIN);
30722 break;
30723 case MINUTE:
30724 jj_consume_token(MINUTE);
30725 break;
30726 case MLSLABEL:
30727 jj_consume_token(MLSLABEL);
30728 break;
30729 case MODIFY:
30730 jj_consume_token(MODIFY);
30731 break;
30732 case MONTH:
30733 jj_consume_token(MONTH);
30734 break;
30735 case MULTISET:
30736 jj_consume_token(MULTISET);
30737 break;
30738 case NAME:
30739 jj_consume_token(NAME);
30740 break;
30741 case NATURAL:
30742 jj_consume_token(NATURAL);
30743 break;
30744 case NCHAR:
30745 jj_consume_token(NCHAR);
30746 break;
30747 case NCHAR_CS:
30748 jj_consume_token(NCHAR_CS);
30749 break;
30750 case NCLOB:
30751 jj_consume_token(NCLOB);
30752 break;
30753 case NESTED:
30754 jj_consume_token(NESTED);
30755 break;
30756 case NEW:
30757 jj_consume_token(NEW);
30758 break;
30759 case NO:
30760 jj_consume_token(NO);
30761 break;
30762 case NOAUDIT:
30763 jj_consume_token(NOAUDIT);
30764 break;
30765 case NUMERIC:
30766 jj_consume_token(NUMERIC);
30767 break;
30768 case NVARCHAR2:
30769 jj_consume_token(NVARCHAR2);
30770 break;
30771 case OBJECT:
30772 jj_consume_token(OBJECT);
30773 break;
30774 case OID:
30775 jj_consume_token(OID);
30776 break;
30777 case OLD:
30778 jj_consume_token(OLD);
30779 break;
30780 case OPAQUE:
30781 jj_consume_token(OPAQUE);
30782 break;
30783 case OPEN:
30784 jj_consume_token(OPEN);
30785 break;
30786 case ORGANIZATION:
30787 jj_consume_token(ORGANIZATION);
30788 break;
30789 case OTHERS:
30790 jj_consume_token(OTHERS);
30791 break;
30792 case OVERRIDING:
30793 jj_consume_token(OVERRIDING);
30794 break;
30795 case PACKAGE:
30796 jj_consume_token(PACKAGE);
30797 break;
30798 case PARAMETERS:
30799 jj_consume_token(PARAMETERS);
30800 break;
30801 case PARENT:
30802 jj_consume_token(PARENT);
30803 break;
30804 case PARTITION:
30805 jj_consume_token(PARTITION);
30806 break;
30807 case PRECISION:
30808 jj_consume_token(PRECISION);
30809 break;
30810 case PRESERVE:
30811 jj_consume_token(PRESERVE);
30812 break;
30813 case PRINT:
30814 jj_consume_token(PRINT);
30815 break;
30816 case PROCEDURE:
30817 jj_consume_token(PROCEDURE);
30818 break;
30819 case QUIT:
30820 jj_consume_token(QUIT);
30821 break;
30822 case RANGE:
30823 jj_consume_token(RANGE);
30824 break;
30825 case REAL:
30826 jj_consume_token(REAL);
30827 break;
30828 case RECORD:
30829 jj_consume_token(RECORD);
30830 break;
30831 case REF:
30832 jj_consume_token(REF);
30833 break;
30834 case RELIES_ON:
30835 jj_consume_token(RELIES_ON);
30836 break;
30837 case REMARK:
30838 jj_consume_token(REMARK);
30839 break;
30840 case RESULT:
30841 jj_consume_token(RESULT);
30842 break;
30843 case RETURN:
30844 jj_consume_token(RETURN);
30845 break;
30846 case RETURNING:
30847 jj_consume_token(RETURNING);
30848 break;
30849 case REVERSE:
30850 jj_consume_token(REVERSE);
30851 break;
30852 case RIGHT:
30853 jj_consume_token(RIGHT);
30854 break;
30855 case ROLLBACK:
30856 jj_consume_token(ROLLBACK);
30857 break;
30858 case ROW:
30859 jj_consume_token(ROW);
30860 break;
30861 case ROWID:
30862 jj_consume_token(ROWID);
30863 break;
30864 case ROWNUM:
30865 jj_consume_token(ROWNUM);
30866 break;
30867 case ROWS:
30868 jj_consume_token(ROWS);
30869 break;
30870 case SAVE:
30871 jj_consume_token(SAVE);
30872 break;
30873 case SAVEPOINT:
30874 jj_consume_token(SAVEPOINT);
30875 break;
30876 case SCHEMA:
30877 jj_consume_token(SCHEMA);
30878 break;
30879 case SECOND:
30880 jj_consume_token(SECOND);
30881 break;
30882 case SELF:
30883 jj_consume_token(SELF);
30884 break;
30885 case SERVERERROR:
30886 jj_consume_token(SERVERERROR);
30887 break;
30888 case SESSIONTIMEZONE:
30889 jj_consume_token(SESSIONTIMEZONE);
30890 break;
30891 case SET:
30892 jj_consume_token(SET);
30893 break;
30894 case SHARED:
30895 jj_consume_token(SHARED);
30896 break;
30897 case SHUTDOWN:
30898 jj_consume_token(SHUTDOWN);
30899 break;
30900 case SPACE:
30901 jj_consume_token(SPACE);
30902 break;
30903 case STARTUP:
30904 jj_consume_token(STARTUP);
30905 break;
30906 case STATEMENT:
30907 jj_consume_token(STATEMENT);
30908 break;
30909 case STATIC:
30910 jj_consume_token(STATIC);
30911 break;
30912 case STATISTICS:
30913 jj_consume_token(STATISTICS);
30914 break;
30915 case STRUCT:
30916 jj_consume_token(STRUCT);
30917 break;
30918 case SUBMULTISET:
30919 jj_consume_token(SUBMULTISET);
30920 break;
30921 case SUBSTITUTABLE:
30922 jj_consume_token(SUBSTITUTABLE);
30923 break;
30924 case SUBTYPE:
30925 jj_consume_token(SUBTYPE);
30926 break;
30927 case SUCCESSFUL:
30928 jj_consume_token(SUCCESSFUL);
30929 break;
30930 case SUSPEND:
30931 jj_consume_token(SUSPEND);
30932 break;
30933 case TDO:
30934 jj_consume_token(TDO);
30935 break;
30936 case TEMPORARY:
30937 jj_consume_token(TEMPORARY);
30938 break;
30939 case TIME:
30940 jj_consume_token(TIME);
30941 break;
30942 case TIMESTAMP:
30943 jj_consume_token(TIMESTAMP);
30944 break;
30945 case TIMEZONE_ABBR:
30946 jj_consume_token(TIMEZONE_ABBR);
30947 break;
30948 case TIMEZONE_HOUR:
30949 jj_consume_token(TIMEZONE_HOUR);
30950 break;
30951 case TIMEZONE_MINUTE:
30952 jj_consume_token(TIMEZONE_MINUTE);
30953 break;
30954 case TIMEZONE_REGION:
30955 jj_consume_token(TIMEZONE_REGION);
30956 break;
30957 case TRAILING:
30958 jj_consume_token(TRAILING);
30959 break;
30960 case TRANSACTION:
30961 jj_consume_token(TRANSACTION);
30962 break;
30963 case TREAT:
30964 jj_consume_token(TREAT);
30965 break;
30966 case TRIM:
30967 jj_consume_token(TRIM);
30968 break;
30969 case TRUNCATE:
30970 jj_consume_token(TRUNCATE);
30971 break;
30972 case UNDEFINE:
30973 jj_consume_token(UNDEFINE);
30974 break;
30975 case UNDER:
30976 jj_consume_token(UNDER);
30977 break;
30978 case UROWID:
30979 jj_consume_token(UROWID);
30980 break;
30981 case USER:
30982 jj_consume_token(USER);
30983 break;
30984 case USING:
30985 jj_consume_token(USING);
30986 break;
30987 case VARRAY:
30988 jj_consume_token(VARRAY);
30989 break;
30990 case VARIABLE:
30991 jj_consume_token(VARIABLE);
30992 break;
30993 case VARYING:
30994 jj_consume_token(VARYING);
30995 break;
30996 case WHENEVER:
30997 jj_consume_token(WHENEVER);
30998 break;
30999 case YEAR:
31000 jj_consume_token(YEAR);
31001 break;
31002 case YES:
31003 jj_consume_token(YES);
31004 break;
31005 case ZONE:
31006 jj_consume_token(ZONE);
31007 break;
31008 case SHOW:
31009 jj_consume_token(SHOW);
31010 break;
31011 case WRAPPED:
31012 jj_consume_token(WRAPPED);
31013 break;
31014 case SYS_REFCURSOR:
31015 jj_consume_token(SYS_REFCURSOR);
31016 break;
31017 case EDITIONABLE:
31018 jj_consume_token(EDITIONABLE);
31019 break;
31020 case NONEDITIONABLE:
31021 jj_consume_token(NONEDITIONABLE);
31022 break;
31023 case ACCESSIBLE:
31024 jj_consume_token(ACCESSIBLE);
31025 break;
31026 case NULLIF:
31027 jj_consume_token(NULLIF);
31028 break;
31029 case RENAME:
31030 jj_consume_token(RENAME);
31031 break;
31032 case RELEASE:
31033 jj_consume_token(RELEASE);
31034 break;
31035 case INLINE:
31036 jj_consume_token(INLINE);
31037 break;
31038 default:
31039 jj_la1[454] = jj_gen;
31040 jj_consume_token(-1);
31041 throw new ParseException();
31042 }
31043 jjtree.closeNodeScope(jjtn000, true);
31044 jjtc000 = false;
31045 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31046 } finally {
31047 if (jjtc000) {
31048 jjtree.closeNodeScope(jjtn000, true);
31049 }
31050 }
31051 throw new Error("Missing return statement in function");
31052 }
31053
31054
31055
31056
31057
31058 final public ASTID ID() throws ParseException {
31059
31060 ASTID jjtn000 = new ASTID(this, JJTID);
31061 boolean jjtc000 = true;
31062 jjtree.openNodeScope(jjtn000);
31063 try {
31064 switch (jj_nt.kind) {
31065 case IDENTIFIER:
31066 jj_consume_token(IDENTIFIER);
31067 break;
31068 case QUOTED_LITERAL:
31069 jj_consume_token(QUOTED_LITERAL);
31070 break;
31071 case DEFINER:
31072 case CURRENT_USER:
31073 case LANGUAGE:
31074 case INLINE:
31075 case ADD:
31076 case AGGREGATE:
31077 case AT:
31078 case ATTRIBUTE:
31079 case AUTHID:
31080 case BULK:
31081 case BYTE:
31082 case CASCADE:
31083 case CLOSE:
31084 case COALESCE:
31085 case COLLECT:
31086 case COLUMN:
31087 case COMMENT:
31088 case COMMIT:
31089 case CONSTRUCTOR:
31090 case CONTINUE:
31091 case CONVERT:
31092 case CURRENT:
31093 case CURSOR:
31094 case DATA:
31095 case DAY:
31096 case DISABLE:
31097 case EDITIONABLE:
31098 case ELEMENT:
31099 case ENABLE:
31100 case ESCAPE:
31101 case EXCEPT:
31102 case EXCEPTIONS:
31103 case EXIT:
31104 case EXTERNAL:
31105 case EXTENDS:
31106 case EXTRACT:
31107 case FALSE:
31108 case FINAL:
31109 case FORCE:
31110 case FUNCTION:
31111 case GLOBAL:
31112 case HASH:
31113 case HEAP:
31114 case HOUR:
31115 case IMMEDIATE:
31116 case INDICES:
31117 case INDEXTYPE:
31118 case INDICATOR:
31119 case INSTANTIABLE:
31120 case INTERVAL:
31121 case INVALIDATE:
31122 case ISOLATION:
31123 case JAVA:
31124 case LEVEL:
31125 case LIMIT:
31126 case MAP:
31127 case MAX:
31128 case MEMBER:
31129 case MERGE:
31130 case MIN:
31131 case MINUTE:
31132 case MLSLABEL:
31133 case MODIFY:
31134 case MONTH:
31135 case NATURAL:
31136 case NEW:
31137 case NO:
31138 case NONEDITIONABLE:
31139 case NULLIF:
31140 case OBJECT:
31141 case OID:
31142 case OPAQUE:
31143 case OPEN:
31144 case ORGANIZATION:
31145 case OTHERS:
31146 case OVERRIDING:
31147 case PACKAGE:
31148 case PARTITION:
31149 case PRESERVE:
31150 case PROCEDURE:
31151 case RANGE:
31152 case REAL:
31153 case RECORD:
31154 case REF:
31155 case RELEASE:
31156 case RELIES_ON:
31157 case RENAME:
31158 case RESULT:
31159 case RETURN:
31160 case RETURNING:
31161 case REVERSE:
31162 case ROLLBACK:
31163 case ROW:
31164 case ROWS:
31165 case ROWID:
31166 case ROWNUM:
31167 case SAVE:
31168 case SAVEPOINT:
31169 case SECOND:
31170 case SELF:
31171 case SET:
31172 case SPACE:
31173 case STATIC:
31174 case SUBTYPE:
31175 case SUBSTITUTABLE:
31176 case SUCCESSFUL:
31177 case SYS_REFCURSOR:
31178 case TEMPORARY:
31179 case TIME:
31180 case TIMESTAMP:
31181 case TIMEZONE_REGION:
31182 case TIMEZONE_ABBR:
31183 case TIMEZONE_MINUTE:
31184 case TIMEZONE_HOUR:
31185 case TRANSACTION:
31186 case TRUE:
31187 case UNDER:
31188 case USING:
31189 case YES:
31190 case SHOW:
31191 case A:
31192 case DOUBLE:
31193 case DEC:
31194 case PRECISION:
31195 case NUMERIC:
31196 case NCHAR:
31197 case NVARCHAR2:
31198 case UROWID:
31199 case VARRAY:
31200 case VARYING:
31201 case BFILE:
31202 case BLOB:
31203 case CLOB:
31204 case NCLOB:
31205 case YEAR:
31206 case LOCAL:
31207 case ZONE:
31208 case CHARACTER:
31209 case AFTER:
31210 case BEFORE:
31211 case OLD:
31212 case PARENT:
31213 case ANALYZE:
31214 case ASSOCIATE:
31215 case AUDIT:
31216 case COMPOUND:
31217 case DATABASE:
31218 case CALL:
31219 case DDL:
31220 case DISASSOCIATE:
31221 case EACH:
31222 case FOLLOWS:
31223 case LOGOFF:
31224 case LOGON:
31225 case NESTED:
31226 case NOAUDIT:
31227 case SCHEMA:
31228 case SERVERERROR:
31229 case SHUTDOWN:
31230 case STARTUP:
31231 case STATEMENT:
31232 case STATISTICS:
31233 case SUSPEND:
31234 case TRUNCATE:
31235 case WRAPPED:
31236 case LIBRARY:
31237 case NAME:
31238 case STRUCT:
31239 case CONTEXT:
31240 case PARAMETERS:
31241 case LENGTH:
31242 case TDO:
31243 case MAXLEN:
31244 case CHARSETID:
31245 case CHARSETFORM:
31246 case ACCEPT:
31247 case ACCESSIBLE:
31248 case COPY:
31249 case DEFINE:
31250 case DISCONNECT:
31251 case HOST:
31252 case PRINT:
31253 case QUIT:
31254 case REMARK:
31255 case UNDEFINE:
31256 case VARIABLE:
31257 case WHENEVER:
31258 case ATTACH:
31259 case CAST:
31260 case TREAT:
31261 case TRIM:
31262 case LEFT:
31263 case RIGHT:
31264 case BOTH:
31265 case EMPTY:
31266 case MULTISET:
31267 case SUBMULTISET:
31268 case LEADING:
31269 case TRAILING:
31270 case CHAR_CS:
31271 case NCHAR_CS:
31272 case DBTIMEZONE:
31273 case SESSIONTIMEZONE:
31274 case AUTHENTICATED:
31275 case LINK:
31276 case SHARED:
31277 case DIRECTORY:
31278 case USER:
31279 KEYWORD_UNRESERVED();
31280 break;
31281 case REPLACE:
31282 jj_consume_token(REPLACE);
31283 break;
31284 case SERIALLY_REUSABLE:
31285 jj_consume_token(SERIALLY_REUSABLE);
31286 break;
31287 case RESTRICT_REFERENCES:
31288 jj_consume_token(RESTRICT_REFERENCES);
31289 break;
31290 case EXCEPTION_INIT:
31291 jj_consume_token(EXCEPTION_INIT);
31292 break;
31293 case AUTONOMOUS_TRANSACTION:
31294 jj_consume_token(AUTONOMOUS_TRANSACTION);
31295 break;
31296 case ALL:
31297 jj_consume_token(ALL);
31298 break;
31299 case ALTER:
31300 jj_consume_token(ALTER);
31301 break;
31302 case AND:
31303 jj_consume_token(AND);
31304 break;
31305 case ANY:
31306 jj_consume_token(ANY);
31307 break;
31308 case ARRAY:
31309 jj_consume_token(ARRAY);
31310 break;
31311 case AS:
31312 jj_consume_token(AS);
31313 break;
31314 case ASC:
31315 jj_consume_token(ASC);
31316 break;
31317 case AVG:
31318 jj_consume_token(AVG);
31319 break;
31320 case BETWEEN:
31321 jj_consume_token(BETWEEN);
31322 break;
31323 case BINARY_INTEGER:
31324 jj_consume_token(BINARY_INTEGER);
31325 break;
31326 case BODY:
31327 jj_consume_token(BODY);
31328 break;
31329 case BOOLEAN:
31330 jj_consume_token(BOOLEAN);
31331 break;
31332 case BY:
31333 jj_consume_token(BY);
31334 break;
31335 case CASE:
31336 jj_consume_token(CASE);
31337 break;
31338 case CHAR:
31339 jj_consume_token(CHAR);
31340 break;
31341 case CHAR_BASE:
31342 jj_consume_token(CHAR_BASE);
31343 break;
31344 case CHECK:
31345 jj_consume_token(CHECK);
31346 break;
31347 case CLUSTER:
31348 jj_consume_token(CLUSTER);
31349 break;
31350 case COMPRESS:
31351 jj_consume_token(COMPRESS);
31352 break;
31353 case CONNECT:
31354 jj_consume_token(CONNECT);
31355 break;
31356 case CONSTANT:
31357 jj_consume_token(CONSTANT);
31358 break;
31359 case CREATE:
31360 jj_consume_token(CREATE);
31361 break;
31362 case CURRVAL:
31363 jj_consume_token(CURRVAL);
31364 break;
31365 case DATE:
31366 jj_consume_token(DATE);
31367 break;
31368 case DECLARE:
31369 jj_consume_token(DECLARE);
31370 break;
31371 case DECIMAL:
31372 jj_consume_token(DECIMAL);
31373 break;
31374 case _DEFAULT:
31375 jj_consume_token(_DEFAULT);
31376 break;
31377 case DELETE:
31378 jj_consume_token(DELETE);
31379 break;
31380 case DESC:
31381 jj_consume_token(DESC);
31382 break;
31383 case DISTINCT:
31384 jj_consume_token(DISTINCT);
31385 break;
31386 case DO:
31387 jj_consume_token(DO);
31388 break;
31389 case DROP:
31390 jj_consume_token(DROP);
31391 break;
31392 case ELSE:
31393 jj_consume_token(ELSE);
31394 break;
31395 case ELSIF:
31396 jj_consume_token(ELSIF);
31397 break;
31398 case EXCEPTION:
31399 jj_consume_token(EXCEPTION);
31400 break;
31401 case EXCLUSIVE:
31402 jj_consume_token(EXCLUSIVE);
31403 break;
31404 case EXECUTE:
31405 jj_consume_token(EXECUTE);
31406 break;
31407 case EXISTS:
31408 jj_consume_token(EXISTS);
31409 break;
31410 case FETCH:
31411 jj_consume_token(FETCH);
31412 break;
31413 case FLOAT:
31414 jj_consume_token(FLOAT);
31415 break;
31416 case FOR:
31417 jj_consume_token(FOR);
31418 break;
31419 case FORALL:
31420 jj_consume_token(FORALL);
31421 break;
31422 case FROM:
31423 jj_consume_token(FROM);
31424 break;
31425 case GOTO:
31426 jj_consume_token(GOTO);
31427 break;
31428 case GROUP:
31429 jj_consume_token(GROUP);
31430 break;
31431 case HAVING:
31432 jj_consume_token(HAVING);
31433 break;
31434 case IF:
31435 jj_consume_token(IF);
31436 break;
31437 case IN:
31438 jj_consume_token(IN);
31439 break;
31440 case INDEX:
31441 jj_consume_token(INDEX);
31442 break;
31443 case INSERT:
31444 jj_consume_token(INSERT);
31445 break;
31446 case INTEGER:
31447 jj_consume_token(INTEGER);
31448 break;
31449 case INTERFACE:
31450 jj_consume_token(INTERFACE);
31451 break;
31452 case INTERSECT:
31453 jj_consume_token(INTERSECT);
31454 break;
31455 case INTO:
31456 jj_consume_token(INTO);
31457 break;
31458 case IS:
31459 jj_consume_token(IS);
31460 break;
31461 case LIKE:
31462 jj_consume_token(LIKE);
31463 break;
31464 case LIMITED:
31465 jj_consume_token(LIMITED);
31466 break;
31467 case LOCK:
31468 jj_consume_token(LOCK);
31469 break;
31470 case LONG:
31471 jj_consume_token(LONG);
31472 break;
31473 case LOOP:
31474 jj_consume_token(LOOP);
31475 break;
31476 case MINUS:
31477 jj_consume_token(MINUS);
31478 break;
31479 case MOD:
31480 jj_consume_token(MOD);
31481 break;
31482 case MODE:
31483 jj_consume_token(MODE);
31484 break;
31485 case NATURALN:
31486 jj_consume_token(NATURALN);
31487 break;
31488 case NEXTVAL:
31489 jj_consume_token(NEXTVAL);
31490 break;
31491 case NOCOPY:
31492 jj_consume_token(NOCOPY);
31493 break;
31494 case NOT:
31495 jj_consume_token(NOT);
31496 break;
31497 case NOWAIT:
31498 jj_consume_token(NOWAIT);
31499 break;
31500 case NULL:
31501 jj_consume_token(NULL);
31502 break;
31503 case NUMBER:
31504 jj_consume_token(NUMBER);
31505 break;
31506 case NUMBER_BASE:
31507 jj_consume_token(NUMBER_BASE);
31508 break;
31509 case OCIROWID:
31510 jj_consume_token(OCIROWID);
31511 break;
31512 case OF:
31513 jj_consume_token(OF);
31514 break;
31515 case ON:
31516 jj_consume_token(ON);
31517 break;
31518 case BFILE_BASE:
31519 jj_consume_token(BFILE_BASE);
31520 break;
31521 case BLOB_BASE:
31522 jj_consume_token(BLOB_BASE);
31523 break;
31524 case CLOB_BASE:
31525 jj_consume_token(CLOB_BASE);
31526 break;
31527 case DATE_BASE:
31528 jj_consume_token(DATE_BASE);
31529 break;
31530 case OPERATOR:
31531 jj_consume_token(OPERATOR);
31532 break;
31533 case OPTION:
31534 jj_consume_token(OPTION);
31535 break;
31536 case OR:
31537 jj_consume_token(OR);
31538 break;
31539 case ORDER:
31540 jj_consume_token(ORDER);
31541 break;
31542 case OUT:
31543 jj_consume_token(OUT);
31544 break;
31545 case PCTFREE:
31546 jj_consume_token(PCTFREE);
31547 break;
31548 case PLS_INTEGER:
31549 jj_consume_token(PLS_INTEGER);
31550 break;
31551 case POSITIVE:
31552 jj_consume_token(POSITIVE);
31553 break;
31554 case POSITIVEN:
31555 jj_consume_token(POSITIVEN);
31556 break;
31557 case PRIOR:
31558 jj_consume_token(PRIOR);
31559 break;
31560 case PRIVATE:
31561 jj_consume_token(PRIVATE);
31562 break;
31563 case PROMPT:
31564 jj_consume_token(PROMPT);
31565 break;
31566 case PUBLIC:
31567 jj_consume_token(PUBLIC);
31568 break;
31569 case RAISE:
31570 jj_consume_token(RAISE);
31571 break;
31572 case RAW:
31573 jj_consume_token(RAW);
31574 break;
31575 case ROWTYPE:
31576 jj_consume_token(ROWTYPE);
31577 break;
31578 case SELECT:
31579 jj_consume_token(SELECT);
31580 break;
31581 case SEPARATE:
31582 jj_consume_token(SEPARATE);
31583 break;
31584 case SHARE:
31585 jj_consume_token(SHARE);
31586 break;
31587 case SMALLINT:
31588 jj_consume_token(SMALLINT);
31589 break;
31590 case SQL:
31591 jj_consume_token(SQL);
31592 break;
31593 case SQLCODE:
31594 jj_consume_token(SQLCODE);
31595 break;
31596 case SQLERRM:
31597 jj_consume_token(SQLERRM);
31598 break;
31599 case START:
31600 jj_consume_token(START);
31601 break;
31602 case STDDEV:
31603 jj_consume_token(STDDEV);
31604 break;
31605 case SUM:
31606 jj_consume_token(SUM);
31607 break;
31608 case SYNONYM:
31609 jj_consume_token(SYNONYM);
31610 break;
31611 case SYSDATE:
31612 jj_consume_token(SYSDATE);
31613 break;
31614 case TABLE:
31615 jj_consume_token(TABLE);
31616 break;
31617 case THEN:
31618 jj_consume_token(THEN);
31619 break;
31620 case TO:
31621 jj_consume_token(TO);
31622 break;
31623 case TRIGGER:
31624 jj_consume_token(TRIGGER);
31625 break;
31626 case TYPE:
31627 jj_consume_token(TYPE);
31628 break;
31629 case UI:
31630 jj_consume_token(UI);
31631 break;
31632 case UPDATE:
31633 jj_consume_token(UPDATE);
31634 break;
31635 case VARCHAR:
31636 jj_consume_token(VARCHAR);
31637 break;
31638 case VARCHAR2:
31639 jj_consume_token(VARCHAR2);
31640 break;
31641 case INT:
31642 jj_consume_token(INT);
31643 break;
31644 case SIGNTYPE:
31645 jj_consume_token(SIGNTYPE);
31646 break;
31647 case STRING:
31648 jj_consume_token(STRING);
31649 break;
31650 case WITH:
31651 jj_consume_token(WITH);
31652 break;
31653 case WHILE:
31654 jj_consume_token(WHILE);
31655 break;
31656 case JAVA_INTERFACE_CLASS:
31657 jj_consume_token(JAVA_INTERFACE_CLASS);
31658 break;
31659 case SQLDATA_CLASS:
31660 jj_consume_token(SQLDATA_CLASS);
31661 break;
31662 case CUSTOMDATUM_CLASS:
31663 jj_consume_token(CUSTOMDATUM_CLASS);
31664 break;
31665 case ORADATA_CLASS:
31666 jj_consume_token(ORADATA_CLASS);
31667 break;
31668 default:
31669 jj_la1[455] = jj_gen;
31670 jj_consume_token(-1);
31671 throw new ParseException();
31672 }
31673 jjtree.closeNodeScope(jjtn000, true);
31674 jjtc000 = false;
31675 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31676 } catch (Throwable jjte000) {
31677 if (jjtc000) {
31678 jjtree.clearNodeScope(jjtn000);
31679 jjtc000 = false;
31680 } else {
31681 jjtree.popNode();
31682 }
31683 if (jjte000 instanceof RuntimeException) {
31684 {if (true) throw (RuntimeException)jjte000;}
31685 }
31686 if (jjte000 instanceof ParseException) {
31687 {if (true) throw (ParseException)jjte000;}
31688 }
31689 {if (true) throw (Error)jjte000;}
31690 } finally {
31691 if (jjtc000) {
31692 jjtree.closeNodeScope(jjtn000, true);
31693 }
31694 }
31695 throw new Error("Missing return statement in function");
31696 }
31697
31698
31699
31700
31701 final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
31702
31703 ASTUnqualifiedID jjtn000 = new ASTUnqualifiedID(this, JJTUNQUALIFIEDID);
31704 boolean jjtc000 = true;
31705 jjtree.openNodeScope(jjtn000);
31706 try {
31707 switch (jj_nt.kind) {
31708 case IDENTIFIER:
31709 jj_consume_token(IDENTIFIER);
31710 break;
31711 case QUOTED_LITERAL:
31712 jj_consume_token(QUOTED_LITERAL);
31713 break;
31714 case DEFINER:
31715 case CURRENT_USER:
31716 case LANGUAGE:
31717 case INLINE:
31718 case ADD:
31719 case AGGREGATE:
31720 case AT:
31721 case ATTRIBUTE:
31722 case AUTHID:
31723 case BULK:
31724 case BYTE:
31725 case CASCADE:
31726 case CLOSE:
31727 case COALESCE:
31728 case COLLECT:
31729 case COLUMN:
31730 case COMMENT:
31731 case COMMIT:
31732 case CONSTRUCTOR:
31733 case CONTINUE:
31734 case CONVERT:
31735 case CURRENT:
31736 case CURSOR:
31737 case DATA:
31738 case DAY:
31739 case DISABLE:
31740 case EDITIONABLE:
31741 case ELEMENT:
31742 case ENABLE:
31743 case ESCAPE:
31744 case EXCEPT:
31745 case EXCEPTIONS:
31746 case EXIT:
31747 case EXTERNAL:
31748 case EXTENDS:
31749 case EXTRACT:
31750 case FALSE:
31751 case FINAL:
31752 case FORCE:
31753 case FUNCTION:
31754 case GLOBAL:
31755 case HASH:
31756 case HEAP:
31757 case HOUR:
31758 case IMMEDIATE:
31759 case INDICES:
31760 case INDEXTYPE:
31761 case INDICATOR:
31762 case INSTANTIABLE:
31763 case INTERVAL:
31764 case INVALIDATE:
31765 case ISOLATION:
31766 case JAVA:
31767 case LEVEL:
31768 case LIMIT:
31769 case MAP:
31770 case MAX:
31771 case MEMBER:
31772 case MERGE:
31773 case MIN:
31774 case MINUTE:
31775 case MLSLABEL:
31776 case MODIFY:
31777 case MONTH:
31778 case NATURAL:
31779 case NEW:
31780 case NO:
31781 case NONEDITIONABLE:
31782 case NULLIF:
31783 case OBJECT:
31784 case OID:
31785 case OPAQUE:
31786 case OPEN:
31787 case ORGANIZATION:
31788 case OTHERS:
31789 case OVERRIDING:
31790 case PACKAGE:
31791 case PARTITION:
31792 case PRESERVE:
31793 case PROCEDURE:
31794 case RANGE:
31795 case REAL:
31796 case RECORD:
31797 case REF:
31798 case RELEASE:
31799 case RELIES_ON:
31800 case RENAME:
31801 case RESULT:
31802 case RETURN:
31803 case RETURNING:
31804 case REVERSE:
31805 case ROLLBACK:
31806 case ROW:
31807 case ROWS:
31808 case ROWID:
31809 case ROWNUM:
31810 case SAVE:
31811 case SAVEPOINT:
31812 case SECOND:
31813 case SELF:
31814 case SET:
31815 case SPACE:
31816 case STATIC:
31817 case SUBTYPE:
31818 case SUBSTITUTABLE:
31819 case SUCCESSFUL:
31820 case SYS_REFCURSOR:
31821 case TEMPORARY:
31822 case TIME:
31823 case TIMESTAMP:
31824 case TIMEZONE_REGION:
31825 case TIMEZONE_ABBR:
31826 case TIMEZONE_MINUTE:
31827 case TIMEZONE_HOUR:
31828 case TRANSACTION:
31829 case TRUE:
31830 case UNDER:
31831 case USING:
31832 case YES:
31833 case SHOW:
31834 case A:
31835 case DOUBLE:
31836 case DEC:
31837 case PRECISION:
31838 case NUMERIC:
31839 case NCHAR:
31840 case NVARCHAR2:
31841 case UROWID:
31842 case VARRAY:
31843 case VARYING:
31844 case BFILE:
31845 case BLOB:
31846 case CLOB:
31847 case NCLOB:
31848 case YEAR:
31849 case LOCAL:
31850 case ZONE:
31851 case CHARACTER:
31852 case AFTER:
31853 case BEFORE:
31854 case OLD:
31855 case PARENT:
31856 case ANALYZE:
31857 case ASSOCIATE:
31858 case AUDIT:
31859 case COMPOUND:
31860 case DATABASE:
31861 case CALL:
31862 case DDL:
31863 case DISASSOCIATE:
31864 case EACH:
31865 case FOLLOWS:
31866 case LOGOFF:
31867 case LOGON:
31868 case NESTED:
31869 case NOAUDIT:
31870 case SCHEMA:
31871 case SERVERERROR:
31872 case SHUTDOWN:
31873 case STARTUP:
31874 case STATEMENT:
31875 case STATISTICS:
31876 case SUSPEND:
31877 case TRUNCATE:
31878 case WRAPPED:
31879 case LIBRARY:
31880 case NAME:
31881 case STRUCT:
31882 case CONTEXT:
31883 case PARAMETERS:
31884 case LENGTH:
31885 case TDO:
31886 case MAXLEN:
31887 case CHARSETID:
31888 case CHARSETFORM:
31889 case ACCEPT:
31890 case ACCESSIBLE:
31891 case COPY:
31892 case DEFINE:
31893 case DISCONNECT:
31894 case HOST:
31895 case PRINT:
31896 case QUIT:
31897 case REMARK:
31898 case UNDEFINE:
31899 case VARIABLE:
31900 case WHENEVER:
31901 case ATTACH:
31902 case CAST:
31903 case TREAT:
31904 case TRIM:
31905 case LEFT:
31906 case RIGHT:
31907 case BOTH:
31908 case EMPTY:
31909 case MULTISET:
31910 case SUBMULTISET:
31911 case LEADING:
31912 case TRAILING:
31913 case CHAR_CS:
31914 case NCHAR_CS:
31915 case DBTIMEZONE:
31916 case SESSIONTIMEZONE:
31917 case AUTHENTICATED:
31918 case LINK:
31919 case SHARED:
31920 case DIRECTORY:
31921 case USER:
31922 KEYWORD_UNRESERVED();
31923 break;
31924 case BODY:
31925 jj_consume_token(BODY);
31926 break;
31927 case MOD:
31928 jj_consume_token(MOD);
31929 break;
31930 case OPERATOR:
31931 jj_consume_token(OPERATOR);
31932 break;
31933 case PRIVATE:
31934 jj_consume_token(PRIVATE);
31935 break;
31936 case RAW:
31937 jj_consume_token(RAW);
31938 break;
31939 case REPLACE:
31940 jj_consume_token(REPLACE);
31941 break;
31942 case STRING:
31943 jj_consume_token(STRING);
31944 break;
31945 case SQL:
31946 jj_consume_token(SQL);
31947 break;
31948 case SQLCODE:
31949 jj_consume_token(SQLCODE);
31950 break;
31951 case SQLERRM:
31952 jj_consume_token(SQLERRM);
31953 break;
31954 case SYSDATE:
31955 jj_consume_token(SYSDATE);
31956 break;
31957 case TYPE:
31958 jj_consume_token(TYPE);
31959 break;
31960 case LOOP:
31961 jj_consume_token(LOOP);
31962 break;
31963 case INT:
31964 jj_consume_token(INT);
31965 break;
31966 case ARRAY:
31967 jj_consume_token(ARRAY);
31968 break;
31969 default:
31970 jj_la1[456] = jj_gen;
31971 jj_consume_token(-1);
31972 throw new ParseException();
31973 }
31974 jjtree.closeNodeScope(jjtn000, true);
31975 jjtc000 = false;
31976 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31977 } catch (Throwable jjte000) {
31978 if (jjtc000) {
31979 jjtree.clearNodeScope(jjtn000);
31980 jjtc000 = false;
31981 } else {
31982 jjtree.popNode();
31983 }
31984 if (jjte000 instanceof RuntimeException) {
31985 {if (true) throw (RuntimeException)jjte000;}
31986 }
31987 if (jjte000 instanceof ParseException) {
31988 {if (true) throw (ParseException)jjte000;}
31989 }
31990 {if (true) throw (Error)jjte000;}
31991 } finally {
31992 if (jjtc000) {
31993 jjtree.closeNodeScope(jjtn000, true);
31994 }
31995 }
31996 throw new Error("Missing return statement in function");
31997 }
31998
31999
32000
32001
32002 final public ASTQualifiedID QualifiedID() throws ParseException {
32003
32004 ASTQualifiedID jjtn000 = new ASTQualifiedID(this, JJTQUALIFIEDID);
32005 boolean jjtc000 = true;
32006 jjtree.openNodeScope(jjtn000);
32007 try {
32008 switch (jj_nt.kind) {
32009 case IDENTIFIER:
32010 jj_consume_token(IDENTIFIER);
32011 break;
32012 case QUOTED_LITERAL:
32013 jj_consume_token(QUOTED_LITERAL);
32014 break;
32015 case DEFINER:
32016 case CURRENT_USER:
32017 case LANGUAGE:
32018 case INLINE:
32019 case ADD:
32020 case AGGREGATE:
32021 case AT:
32022 case ATTRIBUTE:
32023 case AUTHID:
32024 case BULK:
32025 case BYTE:
32026 case CASCADE:
32027 case CLOSE:
32028 case COALESCE:
32029 case COLLECT:
32030 case COLUMN:
32031 case COMMENT:
32032 case COMMIT:
32033 case CONSTRUCTOR:
32034 case CONTINUE:
32035 case CONVERT:
32036 case CURRENT:
32037 case CURSOR:
32038 case DATA:
32039 case DAY:
32040 case DISABLE:
32041 case EDITIONABLE:
32042 case ELEMENT:
32043 case ENABLE:
32044 case ESCAPE:
32045 case EXCEPT:
32046 case EXCEPTIONS:
32047 case EXIT:
32048 case EXTERNAL:
32049 case EXTENDS:
32050 case EXTRACT:
32051 case FALSE:
32052 case FINAL:
32053 case FORCE:
32054 case FUNCTION:
32055 case GLOBAL:
32056 case HASH:
32057 case HEAP:
32058 case HOUR:
32059 case IMMEDIATE:
32060 case INDICES:
32061 case INDEXTYPE:
32062 case INDICATOR:
32063 case INSTANTIABLE:
32064 case INTERVAL:
32065 case INVALIDATE:
32066 case ISOLATION:
32067 case JAVA:
32068 case LEVEL:
32069 case LIMIT:
32070 case MAP:
32071 case MAX:
32072 case MEMBER:
32073 case MERGE:
32074 case MIN:
32075 case MINUTE:
32076 case MLSLABEL:
32077 case MODIFY:
32078 case MONTH:
32079 case NATURAL:
32080 case NEW:
32081 case NO:
32082 case NONEDITIONABLE:
32083 case NULLIF:
32084 case OBJECT:
32085 case OID:
32086 case OPAQUE:
32087 case OPEN:
32088 case ORGANIZATION:
32089 case OTHERS:
32090 case OVERRIDING:
32091 case PACKAGE:
32092 case PARTITION:
32093 case PRESERVE:
32094 case PROCEDURE:
32095 case RANGE:
32096 case REAL:
32097 case RECORD:
32098 case REF:
32099 case RELEASE:
32100 case RELIES_ON:
32101 case RENAME:
32102 case RESULT:
32103 case RETURN:
32104 case RETURNING:
32105 case REVERSE:
32106 case ROLLBACK:
32107 case ROW:
32108 case ROWS:
32109 case ROWID:
32110 case ROWNUM:
32111 case SAVE:
32112 case SAVEPOINT:
32113 case SECOND:
32114 case SELF:
32115 case SET:
32116 case SPACE:
32117 case STATIC:
32118 case SUBTYPE:
32119 case SUBSTITUTABLE:
32120 case SUCCESSFUL:
32121 case SYS_REFCURSOR:
32122 case TEMPORARY:
32123 case TIME:
32124 case TIMESTAMP:
32125 case TIMEZONE_REGION:
32126 case TIMEZONE_ABBR:
32127 case TIMEZONE_MINUTE:
32128 case TIMEZONE_HOUR:
32129 case TRANSACTION:
32130 case TRUE:
32131 case UNDER:
32132 case USING:
32133 case YES:
32134 case SHOW:
32135 case A:
32136 case DOUBLE:
32137 case DEC:
32138 case PRECISION:
32139 case NUMERIC:
32140 case NCHAR:
32141 case NVARCHAR2:
32142 case UROWID:
32143 case VARRAY:
32144 case VARYING:
32145 case BFILE:
32146 case BLOB:
32147 case CLOB:
32148 case NCLOB:
32149 case YEAR:
32150 case LOCAL:
32151 case ZONE:
32152 case CHARACTER:
32153 case AFTER:
32154 case BEFORE:
32155 case OLD:
32156 case PARENT:
32157 case ANALYZE:
32158 case ASSOCIATE:
32159 case AUDIT:
32160 case COMPOUND:
32161 case DATABASE:
32162 case CALL:
32163 case DDL:
32164 case DISASSOCIATE:
32165 case EACH:
32166 case FOLLOWS:
32167 case LOGOFF:
32168 case LOGON:
32169 case NESTED:
32170 case NOAUDIT:
32171 case SCHEMA:
32172 case SERVERERROR:
32173 case SHUTDOWN:
32174 case STARTUP:
32175 case STATEMENT:
32176 case STATISTICS:
32177 case SUSPEND:
32178 case TRUNCATE:
32179 case WRAPPED:
32180 case LIBRARY:
32181 case NAME:
32182 case STRUCT:
32183 case CONTEXT:
32184 case PARAMETERS:
32185 case LENGTH:
32186 case TDO:
32187 case MAXLEN:
32188 case CHARSETID:
32189 case CHARSETFORM:
32190 case ACCEPT:
32191 case ACCESSIBLE:
32192 case COPY:
32193 case DEFINE:
32194 case DISCONNECT:
32195 case HOST:
32196 case PRINT:
32197 case QUIT:
32198 case REMARK:
32199 case UNDEFINE:
32200 case VARIABLE:
32201 case WHENEVER:
32202 case ATTACH:
32203 case CAST:
32204 case TREAT:
32205 case TRIM:
32206 case LEFT:
32207 case RIGHT:
32208 case BOTH:
32209 case EMPTY:
32210 case MULTISET:
32211 case SUBMULTISET:
32212 case LEADING:
32213 case TRAILING:
32214 case CHAR_CS:
32215 case NCHAR_CS:
32216 case DBTIMEZONE:
32217 case SESSIONTIMEZONE:
32218 case AUTHENTICATED:
32219 case LINK:
32220 case SHARED:
32221 case DIRECTORY:
32222 case USER:
32223 KEYWORD_UNRESERVED();
32224 break;
32225 case REPLACE:
32226 jj_consume_token(REPLACE);
32227 break;
32228 case SERIALLY_REUSABLE:
32229 jj_consume_token(SERIALLY_REUSABLE);
32230 break;
32231 case RESTRICT_REFERENCES:
32232 jj_consume_token(RESTRICT_REFERENCES);
32233 break;
32234 case EXCEPTION_INIT:
32235 jj_consume_token(EXCEPTION_INIT);
32236 break;
32237 case AUTONOMOUS_TRANSACTION:
32238 jj_consume_token(AUTONOMOUS_TRANSACTION);
32239 break;
32240 case ARRAY:
32241 jj_consume_token(ARRAY);
32242 break;
32243 case AVG:
32244 jj_consume_token(AVG);
32245 break;
32246 case BINARY_INTEGER:
32247 jj_consume_token(BINARY_INTEGER);
32248 break;
32249 case BODY:
32250 jj_consume_token(BODY);
32251 break;
32252 case BOOLEAN:
32253 jj_consume_token(BOOLEAN);
32254 break;
32255 case CHAR:
32256 jj_consume_token(CHAR);
32257 break;
32258 case CHAR_BASE:
32259 jj_consume_token(CHAR_BASE);
32260 break;
32261 case CONSTANT:
32262 jj_consume_token(CONSTANT);
32263 break;
32264 case CURRVAL:
32265 jj_consume_token(CURRVAL);
32266 break;
32267 case DATE:
32268 jj_consume_token(DATE);
32269 break;
32270 case DECIMAL:
32271 jj_consume_token(DECIMAL);
32272 break;
32273 case DELETE:
32274 jj_consume_token(DELETE);
32275 break;
32276 case DO:
32277 jj_consume_token(DO);
32278 break;
32279 case ELSIF:
32280 jj_consume_token(ELSIF);
32281 break;
32282 case EXECUTE:
32283 jj_consume_token(EXECUTE);
32284 break;
32285 case EXISTS:
32286 jj_consume_token(EXISTS);
32287 break;
32288 case FLOAT:
32289 jj_consume_token(FLOAT);
32290 break;
32291 case FORALL:
32292 jj_consume_token(FORALL);
32293 break;
32294 case INTEGER:
32295 jj_consume_token(INTEGER);
32296 break;
32297 case INTERFACE:
32298 jj_consume_token(INTERFACE);
32299 break;
32300 case LONG:
32301 jj_consume_token(LONG);
32302 break;
32303 case LOOP:
32304 jj_consume_token(LOOP);
32305 break;
32306 case MOD:
32307 jj_consume_token(MOD);
32308 break;
32309 case NATURALN:
32310 jj_consume_token(NATURALN);
32311 break;
32312 case NEXTVAL:
32313 jj_consume_token(NEXTVAL);
32314 break;
32315 case NOCOPY:
32316 jj_consume_token(NOCOPY);
32317 break;
32318 case NUMBER:
32319 jj_consume_token(NUMBER);
32320 break;
32321 case BFILE_BASE:
32322 jj_consume_token(BFILE_BASE);
32323 break;
32324 case BLOB_BASE:
32325 jj_consume_token(BLOB_BASE);
32326 break;
32327 case CLOB_BASE:
32328 jj_consume_token(CLOB_BASE);
32329 break;
32330 case DATE_BASE:
32331 jj_consume_token(DATE_BASE);
32332 break;
32333 case NUMBER_BASE:
32334 jj_consume_token(NUMBER_BASE);
32335 break;
32336 case OCIROWID:
32337 jj_consume_token(OCIROWID);
32338 break;
32339 case OPERATOR:
32340 jj_consume_token(OPERATOR);
32341 break;
32342 case OUT:
32343 jj_consume_token(OUT);
32344 break;
32345 case PLS_INTEGER:
32346 jj_consume_token(PLS_INTEGER);
32347 break;
32348 case POSITIVE:
32349 jj_consume_token(POSITIVE);
32350 break;
32351 case POSITIVEN:
32352 jj_consume_token(POSITIVEN);
32353 break;
32354 case PRAGMA:
32355 jj_consume_token(PRAGMA);
32356 break;
32357 case PRIOR:
32358 jj_consume_token(PRIOR);
32359 break;
32360 case PRIVATE:
32361 jj_consume_token(PRIVATE);
32362 break;
32363 case PROMPT:
32364 jj_consume_token(PROMPT);
32365 break;
32366 case RAISE:
32367 jj_consume_token(RAISE);
32368 break;
32369 case RAW:
32370 jj_consume_token(RAW);
32371 break;
32372 case ROWTYPE:
32373 jj_consume_token(ROWTYPE);
32374 break;
32375 case SEPARATE:
32376 jj_consume_token(SEPARATE);
32377 break;
32378 case SMALLINT:
32379 jj_consume_token(SMALLINT);
32380 break;
32381 case SQLCODE:
32382 jj_consume_token(SQLCODE);
32383 break;
32384 case SQLERRM:
32385 jj_consume_token(SQLERRM);
32386 break;
32387 case STDDEV:
32388 jj_consume_token(STDDEV);
32389 break;
32390 case SUM:
32391 jj_consume_token(SUM);
32392 break;
32393 case SYNONYM:
32394 jj_consume_token(SYNONYM);
32395 break;
32396 case SYSDATE:
32397 jj_consume_token(SYSDATE);
32398 break;
32399 case TRIGGER:
32400 jj_consume_token(TRIGGER);
32401 break;
32402 case TYPE:
32403 jj_consume_token(TYPE);
32404 break;
32405 case UI:
32406 jj_consume_token(UI);
32407 break;
32408 case VARCHAR:
32409 jj_consume_token(VARCHAR);
32410 break;
32411 case VARCHAR2:
32412 jj_consume_token(VARCHAR2);
32413 break;
32414 case INT:
32415 jj_consume_token(INT);
32416 break;
32417 case SIGNTYPE:
32418 jj_consume_token(SIGNTYPE);
32419 break;
32420 case STRING:
32421 jj_consume_token(STRING);
32422 break;
32423 case WHILE:
32424 jj_consume_token(WHILE);
32425 break;
32426 default:
32427 jj_la1[457] = jj_gen;
32428 jj_consume_token(-1);
32429 throw new ParseException();
32430 }
32431 jjtree.closeNodeScope(jjtn000, true);
32432 jjtc000 = false;
32433 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32434 } catch (Throwable jjte000) {
32435 if (jjtc000) {
32436 jjtree.clearNodeScope(jjtn000);
32437 jjtc000 = false;
32438 } else {
32439 jjtree.popNode();
32440 }
32441 if (jjte000 instanceof RuntimeException) {
32442 {if (true) throw (RuntimeException)jjte000;}
32443 }
32444 if (jjte000 instanceof ParseException) {
32445 {if (true) throw (ParseException)jjte000;}
32446 }
32447 {if (true) throw (Error)jjte000;}
32448 } finally {
32449 if (jjtc000) {
32450 jjtree.closeNodeScope(jjtn000, true);
32451 }
32452 }
32453 throw new Error("Missing return statement in function");
32454 }
32455
32456 final public ASTTypeKeyword TypeKeyword() throws ParseException {
32457
32458 ASTTypeKeyword jjtn000 = new ASTTypeKeyword(this, JJTTYPEKEYWORD);
32459 boolean jjtc000 = true;
32460 jjtree.openNodeScope(jjtn000);
32461 try {
32462 switch (jj_nt.kind) {
32463 case BFILE_BASE:
32464 jj_consume_token(BFILE_BASE);
32465 break;
32466 case BLOB_BASE:
32467 jj_consume_token(BLOB_BASE);
32468 break;
32469 case CLOB_BASE:
32470 jj_consume_token(CLOB_BASE);
32471 break;
32472 case DATE_BASE:
32473 jj_consume_token(DATE_BASE);
32474 break;
32475 case NUMBER_BASE:
32476 jj_consume_token(NUMBER_BASE);
32477 break;
32478 case BOOLEAN:
32479 jj_consume_token(BOOLEAN);
32480 break;
32481 case DATE:
32482 jj_consume_token(DATE);
32483 break;
32484 case NUMBER:
32485 jj_consume_token(NUMBER);
32486 break;
32487 case FLOAT:
32488 jj_consume_token(FLOAT);
32489 break;
32490 case REAL:
32491 jj_consume_token(REAL);
32492 break;
32493 case INTEGER:
32494 jj_consume_token(INTEGER);
32495 break;
32496 case INT:
32497 jj_consume_token(INT);
32498 break;
32499 case SMALLINT:
32500 jj_consume_token(SMALLINT);
32501 break;
32502 case DECIMAL:
32503 jj_consume_token(DECIMAL);
32504 break;
32505 case NUMERIC:
32506 jj_consume_token(NUMERIC);
32507 break;
32508 case DEC:
32509 jj_consume_token(DEC);
32510 break;
32511 case BINARY_INTEGER:
32512 jj_consume_token(BINARY_INTEGER);
32513 break;
32514 case NATURAL:
32515 jj_consume_token(NATURAL);
32516 break;
32517 case NATURALN:
32518 jj_consume_token(NATURALN);
32519 break;
32520 case POSITIVE:
32521 jj_consume_token(POSITIVE);
32522 break;
32523 case POSITIVEN:
32524 jj_consume_token(POSITIVEN);
32525 break;
32526 case SIGNTYPE:
32527 jj_consume_token(SIGNTYPE);
32528 break;
32529 case VARCHAR2:
32530 jj_consume_token(VARCHAR2);
32531 break;
32532 case VARCHAR:
32533 jj_consume_token(VARCHAR);
32534 break;
32535 case STRING:
32536 jj_consume_token(STRING);
32537 break;
32538 case LONG:
32539 jj_consume_token(LONG);
32540 break;
32541 case RAW:
32542 jj_consume_token(RAW);
32543 break;
32544 case ROWID:
32545 jj_consume_token(ROWID);
32546 break;
32547 case CHAR:
32548 jj_consume_token(CHAR);
32549 break;
32550 case CHARACTER:
32551 jj_consume_token(CHARACTER);
32552 break;
32553 case MLSLABEL:
32554 jj_consume_token(MLSLABEL);
32555 break;
32556 case BLOB:
32557 jj_consume_token(BLOB);
32558 break;
32559 case CLOB:
32560 jj_consume_token(CLOB);
32561 break;
32562 case BFILE:
32563 jj_consume_token(BFILE);
32564 break;
32565 case NCHAR:
32566 jj_consume_token(NCHAR);
32567 break;
32568 case NVARCHAR2:
32569 jj_consume_token(NVARCHAR2);
32570 break;
32571 case NCLOB:
32572 jj_consume_token(NCLOB);
32573 break;
32574 case PLS_INTEGER:
32575 jj_consume_token(PLS_INTEGER);
32576 break;
32577 case TIME:
32578 jj_consume_token(TIME);
32579 break;
32580 case TIMESTAMP:
32581 jj_consume_token(TIMESTAMP);
32582 break;
32583 case UROWID:
32584 jj_consume_token(UROWID);
32585 break;
32586 case ARRAY:
32587 jj_consume_token(ARRAY);
32588 break;
32589 case AUTHID:
32590 jj_consume_token(AUTHID);
32591 break;
32592 case ACCESSIBLE:
32593 jj_consume_token(ACCESSIBLE);
32594 jj_consume_token(CHAR_BASE);
32595 break;
32596 case CURRVAL:
32597 jj_consume_token(CURRVAL);
32598 break;
32599 case HOUR:
32600 jj_consume_token(HOUR);
32601 break;
32602 case INTERVAL:
32603 jj_consume_token(INTERVAL);
32604 break;
32605 case MONTH:
32606 jj_consume_token(MONTH);
32607 break;
32608 case OCIROWID:
32609 jj_consume_token(OCIROWID);
32610 break;
32611 case RECORD:
32612 jj_consume_token(RECORD);
32613 break;
32614 case REF:
32615 jj_consume_token(REF);
32616 break;
32617 case ROW:
32618 jj_consume_token(ROW);
32619 break;
32620 case ROWNUM:
32621 jj_consume_token(ROWNUM);
32622 break;
32623 case ROWTYPE:
32624 jj_consume_token(ROWTYPE);
32625 break;
32626 case SECOND:
32627 jj_consume_token(SECOND);
32628 break;
32629 case SET:
32630 jj_consume_token(SET);
32631 break;
32632 case TABLE:
32633 jj_consume_token(TABLE);
32634 break;
32635 case TIMEZONE_REGION:
32636 jj_consume_token(TIMEZONE_REGION);
32637 break;
32638 case TIMEZONE_ABBR:
32639 jj_consume_token(TIMEZONE_ABBR);
32640 break;
32641 case TIMEZONE_MINUTE:
32642 jj_consume_token(TIMEZONE_MINUTE);
32643 break;
32644 case TIMEZONE_HOUR:
32645 jj_consume_token(TIMEZONE_HOUR);
32646 break;
32647 case DOUBLE:
32648 jj_consume_token(DOUBLE);
32649 break;
32650 case PRECISION:
32651 jj_consume_token(PRECISION);
32652 break;
32653 case VARRAY:
32654 jj_consume_token(VARRAY);
32655 break;
32656 case YEAR:
32657 jj_consume_token(YEAR);
32658 break;
32659 case LOCAL:
32660 jj_consume_token(LOCAL);
32661 break;
32662 case WITH:
32663 jj_consume_token(WITH);
32664 break;
32665 case ZONE:
32666 jj_consume_token(ZONE);
32667 break;
32668 case JAVA_INTERFACE_CLASS:
32669 jj_consume_token(JAVA_INTERFACE_CLASS);
32670 break;
32671 case SQLDATA_CLASS:
32672 jj_consume_token(SQLDATA_CLASS);
32673 break;
32674 case CUSTOMDATUM_CLASS:
32675 jj_consume_token(CUSTOMDATUM_CLASS);
32676 break;
32677 case ORADATA_CLASS:
32678 jj_consume_token(ORADATA_CLASS);
32679 break;
32680 default:
32681 jj_la1[458] = jj_gen;
32682 jj_consume_token(-1);
32683 throw new ParseException();
32684 }
32685 jjtree.closeNodeScope(jjtn000, true);
32686 jjtc000 = false;
32687 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32688 } finally {
32689 if (jjtc000) {
32690 jjtree.closeNodeScope(jjtn000, true);
32691 }
32692 }
32693 throw new Error("Missing return statement in function");
32694 }
32695
32696 final public ASTJavaInterfaceClass JavaInterfaceClass() throws ParseException {
32697
32698 ASTJavaInterfaceClass jjtn000 = new ASTJavaInterfaceClass(this, JJTJAVAINTERFACECLASS);
32699 boolean jjtc000 = true;
32700 jjtree.openNodeScope(jjtn000);
32701 try {
32702 switch (jj_nt.kind) {
32703 case SQLDATA_CLASS:
32704 jj_consume_token(SQLDATA_CLASS);
32705 break;
32706 case CUSTOMDATUM_CLASS:
32707 jj_consume_token(CUSTOMDATUM_CLASS);
32708 break;
32709 case ORADATA_CLASS:
32710 jj_consume_token(ORADATA_CLASS);
32711 break;
32712 default:
32713 jj_la1[459] = jj_gen;
32714 jj_consume_token(-1);
32715 throw new ParseException();
32716 }
32717 jjtree.closeNodeScope(jjtn000, true);
32718 jjtc000 = false;
32719 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32720 } finally {
32721 if (jjtc000) {
32722 jjtree.closeNodeScope(jjtn000, true);
32723 }
32724 }
32725 throw new Error("Missing return statement in function");
32726 }
32727
32728
32729
32730
32731
32732
32733
32734 final public PLSQLNode EqualsOldIDNewID(PLSQLNode pOldID) throws ParseException {
32735
32736 ASTEqualsOldIDNewID jjtn000 = new ASTEqualsOldIDNewID(this, JJTEQUALSOLDIDNEWID);
32737 boolean jjtc000 = true;
32738 jjtree.openNodeScope(jjtn000);PLSQLNode newID;
32739 Token oldIDToken;
32740 Token newIDToken;
32741 try {
32742 newID = ID();
32743 jjtree.closeNodeScope(jjtn000, true);
32744 jjtc000 = false;
32745 oldIDToken = (Token) ((AbstractPLSQLNode)pOldID).value ;
32746 newIDToken = (Token) ((AbstractPLSQLNode)newID).value ;
32747 if (oldIDToken.image.equals(newIDToken.image)) {
32748 {if (true) return newID;}
32749 } else {
32750 {if (true) throw new ParseException("PLSQL syntax error on line "+newIDToken.beginLine+" at column "+newIDToken.beginColumn+"!\u005cn"
32751 + "Found \u005c""+newIDToken.image+"\u005c" but expected \u005c""+oldIDToken.image+"\u005c".");}
32752 }
32753 } catch (Throwable jjte000) {
32754 if (jjtc000) {
32755 jjtree.clearNodeScope(jjtn000);
32756 jjtc000 = false;
32757 } else {
32758 jjtree.popNode();
32759 }
32760 if (jjte000 instanceof RuntimeException) {
32761 {if (true) throw (RuntimeException)jjte000;}
32762 }
32763 if (jjte000 instanceof ParseException) {
32764 {if (true) throw (ParseException)jjte000;}
32765 }
32766 {if (true) throw (Error)jjte000;}
32767 } finally {
32768 if (jjtc000) {
32769 jjtree.closeNodeScope(jjtn000, true);
32770 }
32771 }
32772 throw new Error("Missing return statement in function");
32773 }
32774
32775 private boolean jj_2_1(int xla) {
32776 jj_la = xla; jj_lastpos = jj_scanpos = token;
32777 try { return !jj_3_1(); }
32778 catch(LookaheadSuccess ls) { return true; }
32779 finally { jj_save(0, xla); }
32780 }
32781
32782 private boolean jj_2_2(int xla) {
32783 jj_la = xla; jj_lastpos = jj_scanpos = token;
32784 try { return !jj_3_2(); }
32785 catch(LookaheadSuccess ls) { return true; }
32786 finally { jj_save(1, xla); }
32787 }
32788
32789 private boolean jj_2_3(int xla) {
32790 jj_la = xla; jj_lastpos = jj_scanpos = token;
32791 try { return !jj_3_3(); }
32792 catch(LookaheadSuccess ls) { return true; }
32793 finally { jj_save(2, xla); }
32794 }
32795
32796 private boolean jj_2_4(int xla) {
32797 jj_la = xla; jj_lastpos = jj_scanpos = token;
32798 try { return !jj_3_4(); }
32799 catch(LookaheadSuccess ls) { return true; }
32800 finally { jj_save(3, xla); }
32801 }
32802
32803 private boolean jj_2_5(int xla) {
32804 jj_la = xla; jj_lastpos = jj_scanpos = token;
32805 try { return !jj_3_5(); }
32806 catch(LookaheadSuccess ls) { return true; }
32807 finally { jj_save(4, xla); }
32808 }
32809
32810 private boolean jj_2_6(int xla) {
32811 jj_la = xla; jj_lastpos = jj_scanpos = token;
32812 try { return !jj_3_6(); }
32813 catch(LookaheadSuccess ls) { return true; }
32814 finally { jj_save(5, xla); }
32815 }
32816
32817 private boolean jj_2_7(int xla) {
32818 jj_la = xla; jj_lastpos = jj_scanpos = token;
32819 try { return !jj_3_7(); }
32820 catch(LookaheadSuccess ls) { return true; }
32821 finally { jj_save(6, xla); }
32822 }
32823
32824 private boolean jj_2_8(int xla) {
32825 jj_la = xla; jj_lastpos = jj_scanpos = token;
32826 try { return !jj_3_8(); }
32827 catch(LookaheadSuccess ls) { return true; }
32828 finally { jj_save(7, xla); }
32829 }
32830
32831 private boolean jj_2_9(int xla) {
32832 jj_la = xla; jj_lastpos = jj_scanpos = token;
32833 try { return !jj_3_9(); }
32834 catch(LookaheadSuccess ls) { return true; }
32835 finally { jj_save(8, xla); }
32836 }
32837
32838 private boolean jj_2_10(int xla) {
32839 jj_la = xla; jj_lastpos = jj_scanpos = token;
32840 try { return !jj_3_10(); }
32841 catch(LookaheadSuccess ls) { return true; }
32842 finally { jj_save(9, xla); }
32843 }
32844
32845 private boolean jj_2_11(int xla) {
32846 jj_la = xla; jj_lastpos = jj_scanpos = token;
32847 try { return !jj_3_11(); }
32848 catch(LookaheadSuccess ls) { return true; }
32849 finally { jj_save(10, xla); }
32850 }
32851
32852 private boolean jj_2_12(int xla) {
32853 jj_la = xla; jj_lastpos = jj_scanpos = token;
32854 try { return !jj_3_12(); }
32855 catch(LookaheadSuccess ls) { return true; }
32856 finally { jj_save(11, xla); }
32857 }
32858
32859 private boolean jj_2_13(int xla) {
32860 jj_la = xla; jj_lastpos = jj_scanpos = token;
32861 try { return !jj_3_13(); }
32862 catch(LookaheadSuccess ls) { return true; }
32863 finally { jj_save(12, xla); }
32864 }
32865
32866 private boolean jj_2_14(int xla) {
32867 jj_la = xla; jj_lastpos = jj_scanpos = token;
32868 try { return !jj_3_14(); }
32869 catch(LookaheadSuccess ls) { return true; }
32870 finally { jj_save(13, xla); }
32871 }
32872
32873 private boolean jj_2_15(int xla) {
32874 jj_la = xla; jj_lastpos = jj_scanpos = token;
32875 try { return !jj_3_15(); }
32876 catch(LookaheadSuccess ls) { return true; }
32877 finally { jj_save(14, xla); }
32878 }
32879
32880 private boolean jj_2_16(int xla) {
32881 jj_la = xla; jj_lastpos = jj_scanpos = token;
32882 try { return !jj_3_16(); }
32883 catch(LookaheadSuccess ls) { return true; }
32884 finally { jj_save(15, xla); }
32885 }
32886
32887 private boolean jj_2_17(int xla) {
32888 jj_la = xla; jj_lastpos = jj_scanpos = token;
32889 try { return !jj_3_17(); }
32890 catch(LookaheadSuccess ls) { return true; }
32891 finally { jj_save(16, xla); }
32892 }
32893
32894 private boolean jj_2_18(int xla) {
32895 jj_la = xla; jj_lastpos = jj_scanpos = token;
32896 try { return !jj_3_18(); }
32897 catch(LookaheadSuccess ls) { return true; }
32898 finally { jj_save(17, xla); }
32899 }
32900
32901 private boolean jj_2_19(int xla) {
32902 jj_la = xla; jj_lastpos = jj_scanpos = token;
32903 try { return !jj_3_19(); }
32904 catch(LookaheadSuccess ls) { return true; }
32905 finally { jj_save(18, xla); }
32906 }
32907
32908 private boolean jj_2_20(int xla) {
32909 jj_la = xla; jj_lastpos = jj_scanpos = token;
32910 try { return !jj_3_20(); }
32911 catch(LookaheadSuccess ls) { return true; }
32912 finally { jj_save(19, xla); }
32913 }
32914
32915 private boolean jj_2_21(int xla) {
32916 jj_la = xla; jj_lastpos = jj_scanpos = token;
32917 try { return !jj_3_21(); }
32918 catch(LookaheadSuccess ls) { return true; }
32919 finally { jj_save(20, xla); }
32920 }
32921
32922 private boolean jj_2_22(int xla) {
32923 jj_la = xla; jj_lastpos = jj_scanpos = token;
32924 try { return !jj_3_22(); }
32925 catch(LookaheadSuccess ls) { return true; }
32926 finally { jj_save(21, xla); }
32927 }
32928
32929 private boolean jj_2_23(int xla) {
32930 jj_la = xla; jj_lastpos = jj_scanpos = token;
32931 try { return !jj_3_23(); }
32932 catch(LookaheadSuccess ls) { return true; }
32933 finally { jj_save(22, xla); }
32934 }
32935
32936 private boolean jj_2_24(int xla) {
32937 jj_la = xla; jj_lastpos = jj_scanpos = token;
32938 try { return !jj_3_24(); }
32939 catch(LookaheadSuccess ls) { return true; }
32940 finally { jj_save(23, xla); }
32941 }
32942
32943 private boolean jj_2_25(int xla) {
32944 jj_la = xla; jj_lastpos = jj_scanpos = token;
32945 try { return !jj_3_25(); }
32946 catch(LookaheadSuccess ls) { return true; }
32947 finally { jj_save(24, xla); }
32948 }
32949
32950 private boolean jj_2_26(int xla) {
32951 jj_la = xla; jj_lastpos = jj_scanpos = token;
32952 try { return !jj_3_26(); }
32953 catch(LookaheadSuccess ls) { return true; }
32954 finally { jj_save(25, xla); }
32955 }
32956
32957 private boolean jj_2_27(int xla) {
32958 jj_la = xla; jj_lastpos = jj_scanpos = token;
32959 try { return !jj_3_27(); }
32960 catch(LookaheadSuccess ls) { return true; }
32961 finally { jj_save(26, xla); }
32962 }
32963
32964 private boolean jj_2_28(int xla) {
32965 jj_la = xla; jj_lastpos = jj_scanpos = token;
32966 try { return !jj_3_28(); }
32967 catch(LookaheadSuccess ls) { return true; }
32968 finally { jj_save(27, xla); }
32969 }
32970
32971 private boolean jj_2_29(int xla) {
32972 jj_la = xla; jj_lastpos = jj_scanpos = token;
32973 try { return !jj_3_29(); }
32974 catch(LookaheadSuccess ls) { return true; }
32975 finally { jj_save(28, xla); }
32976 }
32977
32978 private boolean jj_2_30(int xla) {
32979 jj_la = xla; jj_lastpos = jj_scanpos = token;
32980 try { return !jj_3_30(); }
32981 catch(LookaheadSuccess ls) { return true; }
32982 finally { jj_save(29, xla); }
32983 }
32984
32985 private boolean jj_2_31(int xla) {
32986 jj_la = xla; jj_lastpos = jj_scanpos = token;
32987 try { return !jj_3_31(); }
32988 catch(LookaheadSuccess ls) { return true; }
32989 finally { jj_save(30, xla); }
32990 }
32991
32992 private boolean jj_2_32(int xla) {
32993 jj_la = xla; jj_lastpos = jj_scanpos = token;
32994 try { return !jj_3_32(); }
32995 catch(LookaheadSuccess ls) { return true; }
32996 finally { jj_save(31, xla); }
32997 }
32998
32999 private boolean jj_2_33(int xla) {
33000 jj_la = xla; jj_lastpos = jj_scanpos = token;
33001 try { return !jj_3_33(); }
33002 catch(LookaheadSuccess ls) { return true; }
33003 finally { jj_save(32, xla); }
33004 }
33005
33006 private boolean jj_2_34(int xla) {
33007 jj_la = xla; jj_lastpos = jj_scanpos = token;
33008 try { return !jj_3_34(); }
33009 catch(LookaheadSuccess ls) { return true; }
33010 finally { jj_save(33, xla); }
33011 }
33012
33013 private boolean jj_2_35(int xla) {
33014 jj_la = xla; jj_lastpos = jj_scanpos = token;
33015 try { return !jj_3_35(); }
33016 catch(LookaheadSuccess ls) { return true; }
33017 finally { jj_save(34, xla); }
33018 }
33019
33020 private boolean jj_2_36(int xla) {
33021 jj_la = xla; jj_lastpos = jj_scanpos = token;
33022 try { return !jj_3_36(); }
33023 catch(LookaheadSuccess ls) { return true; }
33024 finally { jj_save(35, xla); }
33025 }
33026
33027 private boolean jj_2_37(int xla) {
33028 jj_la = xla; jj_lastpos = jj_scanpos = token;
33029 try { return !jj_3_37(); }
33030 catch(LookaheadSuccess ls) { return true; }
33031 finally { jj_save(36, xla); }
33032 }
33033
33034 private boolean jj_2_38(int xla) {
33035 jj_la = xla; jj_lastpos = jj_scanpos = token;
33036 try { return !jj_3_38(); }
33037 catch(LookaheadSuccess ls) { return true; }
33038 finally { jj_save(37, xla); }
33039 }
33040
33041 private boolean jj_2_39(int xla) {
33042 jj_la = xla; jj_lastpos = jj_scanpos = token;
33043 try { return !jj_3_39(); }
33044 catch(LookaheadSuccess ls) { return true; }
33045 finally { jj_save(38, xla); }
33046 }
33047
33048 private boolean jj_2_40(int xla) {
33049 jj_la = xla; jj_lastpos = jj_scanpos = token;
33050 try { return !jj_3_40(); }
33051 catch(LookaheadSuccess ls) { return true; }
33052 finally { jj_save(39, xla); }
33053 }
33054
33055 private boolean jj_2_41(int xla) {
33056 jj_la = xla; jj_lastpos = jj_scanpos = token;
33057 try { return !jj_3_41(); }
33058 catch(LookaheadSuccess ls) { return true; }
33059 finally { jj_save(40, xla); }
33060 }
33061
33062 private boolean jj_2_42(int xla) {
33063 jj_la = xla; jj_lastpos = jj_scanpos = token;
33064 try { return !jj_3_42(); }
33065 catch(LookaheadSuccess ls) { return true; }
33066 finally { jj_save(41, xla); }
33067 }
33068
33069 private boolean jj_2_43(int xla) {
33070 jj_la = xla; jj_lastpos = jj_scanpos = token;
33071 try { return !jj_3_43(); }
33072 catch(LookaheadSuccess ls) { return true; }
33073 finally { jj_save(42, xla); }
33074 }
33075
33076 private boolean jj_2_44(int xla) {
33077 jj_la = xla; jj_lastpos = jj_scanpos = token;
33078 try { return !jj_3_44(); }
33079 catch(LookaheadSuccess ls) { return true; }
33080 finally { jj_save(43, xla); }
33081 }
33082
33083 private boolean jj_2_45(int xla) {
33084 jj_la = xla; jj_lastpos = jj_scanpos = token;
33085 try { return !jj_3_45(); }
33086 catch(LookaheadSuccess ls) { return true; }
33087 finally { jj_save(44, xla); }
33088 }
33089
33090 private boolean jj_2_46(int xla) {
33091 jj_la = xla; jj_lastpos = jj_scanpos = token;
33092 try { return !jj_3_46(); }
33093 catch(LookaheadSuccess ls) { return true; }
33094 finally { jj_save(45, xla); }
33095 }
33096
33097 private boolean jj_2_47(int xla) {
33098 jj_la = xla; jj_lastpos = jj_scanpos = token;
33099 try { return !jj_3_47(); }
33100 catch(LookaheadSuccess ls) { return true; }
33101 finally { jj_save(46, xla); }
33102 }
33103
33104 private boolean jj_2_48(int xla) {
33105 jj_la = xla; jj_lastpos = jj_scanpos = token;
33106 try { return !jj_3_48(); }
33107 catch(LookaheadSuccess ls) { return true; }
33108 finally { jj_save(47, xla); }
33109 }
33110
33111 private boolean jj_2_49(int xla) {
33112 jj_la = xla; jj_lastpos = jj_scanpos = token;
33113 try { return !jj_3_49(); }
33114 catch(LookaheadSuccess ls) { return true; }
33115 finally { jj_save(48, xla); }
33116 }
33117
33118 private boolean jj_2_50(int xla) {
33119 jj_la = xla; jj_lastpos = jj_scanpos = token;
33120 try { return !jj_3_50(); }
33121 catch(LookaheadSuccess ls) { return true; }
33122 finally { jj_save(49, xla); }
33123 }
33124
33125 private boolean jj_2_51(int xla) {
33126 jj_la = xla; jj_lastpos = jj_scanpos = token;
33127 try { return !jj_3_51(); }
33128 catch(LookaheadSuccess ls) { return true; }
33129 finally { jj_save(50, xla); }
33130 }
33131
33132 private boolean jj_2_52(int xla) {
33133 jj_la = xla; jj_lastpos = jj_scanpos = token;
33134 try { return !jj_3_52(); }
33135 catch(LookaheadSuccess ls) { return true; }
33136 finally { jj_save(51, xla); }
33137 }
33138
33139 private boolean jj_2_53(int xla) {
33140 jj_la = xla; jj_lastpos = jj_scanpos = token;
33141 try { return !jj_3_53(); }
33142 catch(LookaheadSuccess ls) { return true; }
33143 finally { jj_save(52, xla); }
33144 }
33145
33146 private boolean jj_2_54(int xla) {
33147 jj_la = xla; jj_lastpos = jj_scanpos = token;
33148 try { return !jj_3_54(); }
33149 catch(LookaheadSuccess ls) { return true; }
33150 finally { jj_save(53, xla); }
33151 }
33152
33153 private boolean jj_2_55(int xla) {
33154 jj_la = xla; jj_lastpos = jj_scanpos = token;
33155 try { return !jj_3_55(); }
33156 catch(LookaheadSuccess ls) { return true; }
33157 finally { jj_save(54, xla); }
33158 }
33159
33160 private boolean jj_2_56(int xla) {
33161 jj_la = xla; jj_lastpos = jj_scanpos = token;
33162 try { return !jj_3_56(); }
33163 catch(LookaheadSuccess ls) { return true; }
33164 finally { jj_save(55, xla); }
33165 }
33166
33167 private boolean jj_2_57(int xla) {
33168 jj_la = xla; jj_lastpos = jj_scanpos = token;
33169 try { return !jj_3_57(); }
33170 catch(LookaheadSuccess ls) { return true; }
33171 finally { jj_save(56, xla); }
33172 }
33173
33174 private boolean jj_2_58(int xla) {
33175 jj_la = xla; jj_lastpos = jj_scanpos = token;
33176 try { return !jj_3_58(); }
33177 catch(LookaheadSuccess ls) { return true; }
33178 finally { jj_save(57, xla); }
33179 }
33180
33181 private boolean jj_2_59(int xla) {
33182 jj_la = xla; jj_lastpos = jj_scanpos = token;
33183 try { return !jj_3_59(); }
33184 catch(LookaheadSuccess ls) { return true; }
33185 finally { jj_save(58, xla); }
33186 }
33187
33188 private boolean jj_2_60(int xla) {
33189 jj_la = xla; jj_lastpos = jj_scanpos = token;
33190 try { return !jj_3_60(); }
33191 catch(LookaheadSuccess ls) { return true; }
33192 finally { jj_save(59, xla); }
33193 }
33194
33195 private boolean jj_2_61(int xla) {
33196 jj_la = xla; jj_lastpos = jj_scanpos = token;
33197 try { return !jj_3_61(); }
33198 catch(LookaheadSuccess ls) { return true; }
33199 finally { jj_save(60, xla); }
33200 }
33201
33202 private boolean jj_2_62(int xla) {
33203 jj_la = xla; jj_lastpos = jj_scanpos = token;
33204 try { return !jj_3_62(); }
33205 catch(LookaheadSuccess ls) { return true; }
33206 finally { jj_save(61, xla); }
33207 }
33208
33209 private boolean jj_2_63(int xla) {
33210 jj_la = xla; jj_lastpos = jj_scanpos = token;
33211 try { return !jj_3_63(); }
33212 catch(LookaheadSuccess ls) { return true; }
33213 finally { jj_save(62, xla); }
33214 }
33215
33216 private boolean jj_2_64(int xla) {
33217 jj_la = xla; jj_lastpos = jj_scanpos = token;
33218 try { return !jj_3_64(); }
33219 catch(LookaheadSuccess ls) { return true; }
33220 finally { jj_save(63, xla); }
33221 }
33222
33223 private boolean jj_2_65(int xla) {
33224 jj_la = xla; jj_lastpos = jj_scanpos = token;
33225 try { return !jj_3_65(); }
33226 catch(LookaheadSuccess ls) { return true; }
33227 finally { jj_save(64, xla); }
33228 }
33229
33230 private boolean jj_2_66(int xla) {
33231 jj_la = xla; jj_lastpos = jj_scanpos = token;
33232 try { return !jj_3_66(); }
33233 catch(LookaheadSuccess ls) { return true; }
33234 finally { jj_save(65, xla); }
33235 }
33236
33237 private boolean jj_2_67(int xla) {
33238 jj_la = xla; jj_lastpos = jj_scanpos = token;
33239 try { return !jj_3_67(); }
33240 catch(LookaheadSuccess ls) { return true; }
33241 finally { jj_save(66, xla); }
33242 }
33243
33244 private boolean jj_2_68(int xla) {
33245 jj_la = xla; jj_lastpos = jj_scanpos = token;
33246 try { return !jj_3_68(); }
33247 catch(LookaheadSuccess ls) { return true; }
33248 finally { jj_save(67, xla); }
33249 }
33250
33251 private boolean jj_2_69(int xla) {
33252 jj_la = xla; jj_lastpos = jj_scanpos = token;
33253 try { return !jj_3_69(); }
33254 catch(LookaheadSuccess ls) { return true; }
33255 finally { jj_save(68, xla); }
33256 }
33257
33258 private boolean jj_2_70(int xla) {
33259 jj_la = xla; jj_lastpos = jj_scanpos = token;
33260 try { return !jj_3_70(); }
33261 catch(LookaheadSuccess ls) { return true; }
33262 finally { jj_save(69, xla); }
33263 }
33264
33265 private boolean jj_2_71(int xla) {
33266 jj_la = xla; jj_lastpos = jj_scanpos = token;
33267 try { return !jj_3_71(); }
33268 catch(LookaheadSuccess ls) { return true; }
33269 finally { jj_save(70, xla); }
33270 }
33271
33272 private boolean jj_2_72(int xla) {
33273 jj_la = xla; jj_lastpos = jj_scanpos = token;
33274 try { return !jj_3_72(); }
33275 catch(LookaheadSuccess ls) { return true; }
33276 finally { jj_save(71, xla); }
33277 }
33278
33279 private boolean jj_2_73(int xla) {
33280 jj_la = xla; jj_lastpos = jj_scanpos = token;
33281 try { return !jj_3_73(); }
33282 catch(LookaheadSuccess ls) { return true; }
33283 finally { jj_save(72, xla); }
33284 }
33285
33286 private boolean jj_2_74(int xla) {
33287 jj_la = xla; jj_lastpos = jj_scanpos = token;
33288 try { return !jj_3_74(); }
33289 catch(LookaheadSuccess ls) { return true; }
33290 finally { jj_save(73, xla); }
33291 }
33292
33293 private boolean jj_2_75(int xla) {
33294 jj_la = xla; jj_lastpos = jj_scanpos = token;
33295 try { return !jj_3_75(); }
33296 catch(LookaheadSuccess ls) { return true; }
33297 finally { jj_save(74, xla); }
33298 }
33299
33300 private boolean jj_2_76(int xla) {
33301 jj_la = xla; jj_lastpos = jj_scanpos = token;
33302 try { return !jj_3_76(); }
33303 catch(LookaheadSuccess ls) { return true; }
33304 finally { jj_save(75, xla); }
33305 }
33306
33307 private boolean jj_2_77(int xla) {
33308 jj_la = xla; jj_lastpos = jj_scanpos = token;
33309 try { return !jj_3_77(); }
33310 catch(LookaheadSuccess ls) { return true; }
33311 finally { jj_save(76, xla); }
33312 }
33313
33314 private boolean jj_2_78(int xla) {
33315 jj_la = xla; jj_lastpos = jj_scanpos = token;
33316 try { return !jj_3_78(); }
33317 catch(LookaheadSuccess ls) { return true; }
33318 finally { jj_save(77, xla); }
33319 }
33320
33321 private boolean jj_2_79(int xla) {
33322 jj_la = xla; jj_lastpos = jj_scanpos = token;
33323 try { return !jj_3_79(); }
33324 catch(LookaheadSuccess ls) { return true; }
33325 finally { jj_save(78, xla); }
33326 }
33327
33328 private boolean jj_2_80(int xla) {
33329 jj_la = xla; jj_lastpos = jj_scanpos = token;
33330 try { return !jj_3_80(); }
33331 catch(LookaheadSuccess ls) { return true; }
33332 finally { jj_save(79, xla); }
33333 }
33334
33335 private boolean jj_2_81(int xla) {
33336 jj_la = xla; jj_lastpos = jj_scanpos = token;
33337 try { return !jj_3_81(); }
33338 catch(LookaheadSuccess ls) { return true; }
33339 finally { jj_save(80, xla); }
33340 }
33341
33342 private boolean jj_2_82(int xla) {
33343 jj_la = xla; jj_lastpos = jj_scanpos = token;
33344 try { return !jj_3_82(); }
33345 catch(LookaheadSuccess ls) { return true; }
33346 finally { jj_save(81, xla); }
33347 }
33348
33349 private boolean jj_2_83(int xla) {
33350 jj_la = xla; jj_lastpos = jj_scanpos = token;
33351 try { return !jj_3_83(); }
33352 catch(LookaheadSuccess ls) { return true; }
33353 finally { jj_save(82, xla); }
33354 }
33355
33356 private boolean jj_2_84(int xla) {
33357 jj_la = xla; jj_lastpos = jj_scanpos = token;
33358 try { return !jj_3_84(); }
33359 catch(LookaheadSuccess ls) { return true; }
33360 finally { jj_save(83, xla); }
33361 }
33362
33363 private boolean jj_2_85(int xla) {
33364 jj_la = xla; jj_lastpos = jj_scanpos = token;
33365 try { return !jj_3_85(); }
33366 catch(LookaheadSuccess ls) { return true; }
33367 finally { jj_save(84, xla); }
33368 }
33369
33370 private boolean jj_3R_565() {
33371 Token xsp;
33372 xsp = jj_scanpos;
33373 if (jj_scan_token(183)) jj_scanpos = xsp;
33374 if (jj_scan_token(NULL)) return true;
33375 return false;
33376 }
33377
33378 private boolean jj_3R_179() {
33379 Token xsp;
33380 xsp = jj_scanpos;
33381 if (jj_3_77()) jj_scanpos = xsp;
33382 if (jj_3R_124()) return true;
33383 return false;
33384 }
33385
33386 private boolean jj_3_78() {
33387 if (jj_scan_token(NESTED)) return true;
33388 if (jj_scan_token(TABLE)) return true;
33389 return false;
33390 }
33391
33392 private boolean jj_3R_530() {
33393 if (jj_scan_token(6)) return true;
33394 if (jj_3R_234()) return true;
33395 return false;
33396 }
33397
33398 private boolean jj_3R_525() {
33399 if (jj_scan_token(VARYING)) return true;
33400 if (jj_scan_token(ARRAY)) return true;
33401 return false;
33402 }
33403
33404 private boolean jj_3R_178() {
33405 if (jj_scan_token(OR)) return true;
33406 Token xsp;
33407 xsp = jj_scanpos;
33408 if (jj_3R_269()) {
33409 jj_scanpos = xsp;
33410 if (jj_3R_270()) return true;
33411 }
33412 return false;
33413 }
33414
33415 private boolean jj_3R_529() {
33416 if (jj_scan_token(RETURN)) return true;
33417 if (jj_3R_236()) return true;
33418 return false;
33419 }
33420
33421 private boolean jj_3R_176() {
33422 Token xsp;
33423 xsp = jj_scanpos;
33424 if (jj_scan_token(93)) {
33425 jj_scanpos = xsp;
33426 if (jj_scan_token(144)) {
33427 jj_scanpos = xsp;
33428 if (jj_scan_token(297)) return true;
33429 }
33430 }
33431 xsp = jj_scanpos;
33432 if (jj_3_74()) jj_scanpos = xsp;
33433 return false;
33434 }
33435
33436 private boolean jj_3R_527() {
33437 if (jj_scan_token(NOT)) return true;
33438 if (jj_scan_token(NULL)) return true;
33439 return false;
33440 }
33441
33442 private boolean jj_3R_266() {
33443 if (jj_scan_token(OR)) return true;
33444 if (jj_scan_token(REPLACE)) return true;
33445 return false;
33446 }
33447
33448 private boolean jj_3R_123() {
33449 Token xsp;
33450 xsp = jj_scanpos;
33451 if (jj_scan_token(114)) {
33452 jj_scanpos = xsp;
33453 if (jj_3R_200()) return true;
33454 }
33455 while (true) {
33456 xsp = jj_scanpos;
33457 if (jj_3R_201()) { jj_scanpos = xsp; break; }
33458 }
33459 return false;
33460 }
33461
33462 private boolean jj_3R_499() {
33463 if (jj_3R_236()) return true;
33464 return false;
33465 }
33466
33467 private boolean jj_3R_175() {
33468 if (jj_scan_token(CREATE)) return true;
33469 Token xsp;
33470 xsp = jj_scanpos;
33471 if (jj_3R_266()) jj_scanpos = xsp;
33472 xsp = jj_scanpos;
33473 if (jj_3R_267()) jj_scanpos = xsp;
33474 return false;
33475 }
33476
33477 private boolean jj_3R_498() {
33478 if (jj_scan_token(5)) return true;
33479 if (jj_3R_234()) return true;
33480 Token xsp;
33481 while (true) {
33482 xsp = jj_scanpos;
33483 if (jj_3R_530()) { jj_scanpos = xsp; break; }
33484 }
33485 if (jj_scan_token(7)) return true;
33486 return false;
33487 }
33488
33489 private boolean jj_3R_108() {
33490 Token xsp;
33491 xsp = jj_scanpos;
33492 if (jj_3R_175()) jj_scanpos = xsp;
33493 if (jj_scan_token(TRIGGER)) return true;
33494 if (jj_3R_155()) return true;
33495 xsp = jj_scanpos;
33496 if (jj_scan_token(322)) {
33497 jj_scanpos = xsp;
33498 if (jj_scan_token(321)) {
33499 jj_scanpos = xsp;
33500 if (jj_scan_token(323)) {
33501 jj_scanpos = xsp;
33502 if (jj_scan_token(121)) return true;
33503 }
33504 }
33505 }
33506 xsp = jj_scanpos;
33507 if (jj_3R_176()) {
33508 jj_scanpos = xsp;
33509 if (jj_3R_177()) return true;
33510 }
33511 while (true) {
33512 xsp = jj_scanpos;
33513 if (jj_3R_178()) { jj_scanpos = xsp; break; }
33514 }
33515 if (jj_scan_token(ON)) return true;
33516 xsp = jj_scanpos;
33517 if (jj_scan_token(348)) {
33518 jj_scanpos = xsp;
33519 if (jj_3_78()) {
33520 jj_scanpos = xsp;
33521 if (jj_3R_179()) return true;
33522 }
33523 }
33524 return false;
33525 }
33526
33527 private boolean jj_3R_497() {
33528 if (jj_scan_token(REF)) return true;
33529 if (jj_scan_token(CURSOR)) return true;
33530 Token xsp;
33531 xsp = jj_scanpos;
33532 if (jj_3R_529()) jj_scanpos = xsp;
33533 return false;
33534 }
33535
33536 private boolean jj_3R_522() {
33537 if (jj_3R_124()) return true;
33538 if (jj_3R_236()) return true;
33539 Token xsp;
33540 xsp = jj_scanpos;
33541 if (jj_3R_565()) jj_scanpos = xsp;
33542 xsp = jj_scanpos;
33543 if (jj_3R_566()) jj_scanpos = xsp;
33544 return false;
33545 }
33546
33547 private boolean jj_3R_496() {
33548 Token xsp;
33549 xsp = jj_scanpos;
33550 if (jj_scan_token(271)) {
33551 jj_scanpos = xsp;
33552 if (jj_scan_token(310)) {
33553 jj_scanpos = xsp;
33554 if (jj_3R_525()) return true;
33555 }
33556 }
33557 xsp = jj_scanpos;
33558 if (jj_3R_526()) jj_scanpos = xsp;
33559 if (jj_scan_token(OF)) return true;
33560 if (jj_3R_236()) return true;
33561 xsp = jj_scanpos;
33562 if (jj_3R_527()) jj_scanpos = xsp;
33563 xsp = jj_scanpos;
33564 if (jj_3R_528()) jj_scanpos = xsp;
33565 return false;
33566 }
33567
33568 private boolean jj_3R_495() {
33569 if (jj_scan_token(RECORD)) return true;
33570 if (jj_scan_token(5)) return true;
33571 if (jj_3R_522()) return true;
33572 Token xsp;
33573 while (true) {
33574 xsp = jj_scanpos;
33575 if (jj_3R_524()) { jj_scanpos = xsp; break; }
33576 }
33577 if (jj_scan_token(7)) return true;
33578 return false;
33579 }
33580
33581 private boolean jj_3R_494() {
33582 if (jj_scan_token(OBJECT)) return true;
33583 if (jj_scan_token(5)) return true;
33584 if (jj_3R_522()) return true;
33585 Token xsp;
33586 while (true) {
33587 xsp = jj_scanpos;
33588 if (jj_3R_523()) { jj_scanpos = xsp; break; }
33589 }
33590 if (jj_scan_token(7)) return true;
33591 return false;
33592 }
33593
33594 private boolean jj_3R_645() {
33595 if (jj_3R_174()) return true;
33596 return false;
33597 }
33598
33599 private boolean jj_3_44() {
33600 if (jj_scan_token(NEW)) return true;
33601 Token xsp;
33602 xsp = jj_scanpos;
33603 if (jj_scan_token(68)) {
33604 jj_scanpos = xsp;
33605 if (jj_scan_token(191)) {
33606 jj_scanpos = xsp;
33607 if (jj_scan_token(190)) {
33608 jj_scanpos = xsp;
33609 if (jj_scan_token(189)) {
33610 jj_scanpos = xsp;
33611 if (jj_scan_token(188)) {
33612 jj_scanpos = xsp;
33613 if (jj_scan_token(192)) return true;
33614 }
33615 }
33616 }
33617 }
33618 }
33619 return false;
33620 }
33621
33622 private boolean jj_3R_595() {
33623 if (jj_3R_174()) return true;
33624 return false;
33625 }
33626
33627 private boolean jj_3R_646() {
33628 Token xsp;
33629 xsp = jj_scanpos;
33630 if (jj_scan_token(137)) {
33631 jj_scanpos = xsp;
33632 if (jj_scan_token(207)) {
33633 jj_scanpos = xsp;
33634 if (jj_scan_token(138)) return true;
33635 }
33636 }
33637 return false;
33638 }
33639
33640 private boolean jj_3R_493() {
33641 if (jj_scan_token(NOT)) return true;
33642 if (jj_scan_token(NULL)) return true;
33643 return false;
33644 }
33645
33646 private boolean jj_3R_521() {
33647 if (jj_scan_token(RANGE)) return true;
33648 if (jj_3R_484()) return true;
33649 if (jj_scan_token(12)) return true;
33650 if (jj_3R_484()) return true;
33651 return false;
33652 }
33653
33654 private boolean jj_3R_520() {
33655 if (jj_scan_token(5)) return true;
33656 if (jj_scan_token(IDENTIFIER)) return true;
33657 if (jj_scan_token(7)) return true;
33658 return false;
33659 }
33660
33661 private boolean jj_3R_492() {
33662 Token xsp;
33663 xsp = jj_scanpos;
33664 if (jj_3R_520()) {
33665 jj_scanpos = xsp;
33666 if (jj_3R_521()) return true;
33667 }
33668 return false;
33669 }
33670
33671 private boolean jj_3R_647() {
33672 if (jj_scan_token(IN)) return true;
33673 Token xsp;
33674 xsp = jj_scanpos;
33675 if (jj_scan_token(207)) jj_scanpos = xsp;
33676 return false;
33677 }
33678
33679 private boolean jj_3R_644() {
33680 Token xsp;
33681 xsp = jj_scanpos;
33682 if (jj_3R_647()) {
33683 jj_scanpos = xsp;
33684 if (jj_scan_token(207)) return true;
33685 }
33686 return false;
33687 }
33688
33689 private boolean jj_3R_643() {
33690 if (jj_scan_token(6)) return true;
33691 Token xsp;
33692 xsp = jj_scanpos;
33693 if (jj_3R_646()) jj_scanpos = xsp;
33694 if (jj_3R_234()) return true;
33695 return false;
33696 }
33697
33698 private boolean jj_3R_244() {
33699 if (jj_scan_token(TYPE)) return true;
33700 if (jj_3R_120()) return true;
33701 Token xsp;
33702 xsp = jj_scanpos;
33703 if (jj_scan_token(152)) {
33704 jj_scanpos = xsp;
33705 if (jj_scan_token(51)) return true;
33706 }
33707 xsp = jj_scanpos;
33708 if (jj_3_44()) {
33709 jj_scanpos = xsp;
33710 if (jj_3R_494()) {
33711 jj_scanpos = xsp;
33712 if (jj_3R_495()) {
33713 jj_scanpos = xsp;
33714 if (jj_3R_496()) {
33715 jj_scanpos = xsp;
33716 if (jj_3R_497()) {
33717 jj_scanpos = xsp;
33718 if (jj_3R_498()) {
33719 jj_scanpos = xsp;
33720 if (jj_3R_499()) return true;
33721 }
33722 }
33723 }
33724 }
33725 }
33726 }
33727 return false;
33728 }
33729
33730 private boolean jj_3R_641() {
33731 if (jj_scan_token(6)) return true;
33732 if (jj_3R_234()) return true;
33733 return false;
33734 }
33735
33736 private boolean jj_3R_640() {
33737 if (jj_scan_token(6)) return true;
33738 Token xsp;
33739 xsp = jj_scanpos;
33740 if (jj_3R_644()) jj_scanpos = xsp;
33741 if (jj_3R_234()) return true;
33742 return false;
33743 }
33744
33745 private boolean jj_3R_243() {
33746 if (jj_scan_token(SUBTYPE)) return true;
33747 if (jj_3R_120()) return true;
33748 if (jj_scan_token(IS)) return true;
33749 if (jj_3R_236()) return true;
33750 Token xsp;
33751 xsp = jj_scanpos;
33752 if (jj_3R_492()) jj_scanpos = xsp;
33753 xsp = jj_scanpos;
33754 if (jj_3R_493()) jj_scanpos = xsp;
33755 return false;
33756 }
33757
33758 private boolean jj_3R_620() {
33759 if (jj_3R_174()) return true;
33760 return false;
33761 }
33762
33763 private boolean jj_3R_153() {
33764 Token xsp;
33765 xsp = jj_scanpos;
33766 if (jj_3R_243()) {
33767 jj_scanpos = xsp;
33768 if (jj_3R_244()) return true;
33769 }
33770 if (jj_scan_token(4)) return true;
33771 return false;
33772 }
33773
33774 private boolean jj_3R_556() {
33775 if (jj_scan_token(LIMIT)) return true;
33776 if (jj_3R_234()) return true;
33777 return false;
33778 }
33779
33780 private boolean jj_3R_597() {
33781 if (jj_scan_token(CC_ELSE)) return true;
33782 Token xsp;
33783 if (jj_3R_620()) return true;
33784 while (true) {
33785 xsp = jj_scanpos;
33786 if (jj_3R_620()) { jj_scanpos = xsp; break; }
33787 }
33788 return false;
33789 }
33790
33791 private boolean jj_3R_596() {
33792 if (jj_scan_token(CC_ELSIF)) return true;
33793 if (jj_3R_344()) return true;
33794 if (jj_scan_token(CC_THEN)) return true;
33795 Token xsp;
33796 if (jj_3R_645()) return true;
33797 while (true) {
33798 xsp = jj_scanpos;
33799 if (jj_3R_645()) { jj_scanpos = xsp; break; }
33800 }
33801 return false;
33802 }
33803
33804 private boolean jj_3R_457() {
33805 if (jj_scan_token(CC_ERROR)) return true;
33806 if (jj_3R_234()) return true;
33807 if (jj_scan_token(CC_END)) return true;
33808 return false;
33809 }
33810
33811 private boolean jj_3R_404() {
33812 if (jj_scan_token(INTERFACE)) return true;
33813 if (jj_scan_token(5)) return true;
33814 return false;
33815 }
33816
33817 private boolean jj_3R_403() {
33818 if (jj_scan_token(EXCEPTION_INIT)) return true;
33819 if (jj_scan_token(5)) return true;
33820 return false;
33821 }
33822
33823 private boolean jj_3R_456() {
33824 if (jj_scan_token(CC_IF)) return true;
33825 if (jj_3R_344()) return true;
33826 if (jj_scan_token(CC_THEN)) return true;
33827 Token xsp;
33828 while (true) {
33829 xsp = jj_scanpos;
33830 if (jj_3R_595()) { jj_scanpos = xsp; break; }
33831 }
33832 while (true) {
33833 xsp = jj_scanpos;
33834 if (jj_3R_596()) { jj_scanpos = xsp; break; }
33835 }
33836 while (true) {
33837 xsp = jj_scanpos;
33838 if (jj_3R_597()) { jj_scanpos = xsp; break; }
33839 }
33840 if (jj_scan_token(CC_END)) return true;
33841 return false;
33842 }
33843
33844 private boolean jj_3R_618() {
33845 Token xsp;
33846 xsp = jj_scanpos;
33847 if (jj_scan_token(137)) {
33848 jj_scanpos = xsp;
33849 if (jj_scan_token(207)) {
33850 jj_scanpos = xsp;
33851 if (jj_scan_token(138)) return true;
33852 }
33853 }
33854 return false;
33855 }
33856
33857 private boolean jj_3R_639() {
33858 if (jj_scan_token(6)) return true;
33859 if (jj_3R_295()) return true;
33860 return false;
33861 }
33862
33863 private boolean jj_3R_421() {
33864 Token xsp;
33865 xsp = jj_scanpos;
33866 if (jj_3R_456()) {
33867 jj_scanpos = xsp;
33868 if (jj_3R_457()) return true;
33869 }
33870 return false;
33871 }
33872
33873 private boolean jj_3R_402() {
33874 if (jj_scan_token(RESTRICT_REFERENCES)) return true;
33875 if (jj_scan_token(5)) return true;
33876 return false;
33877 }
33878
33879 private boolean jj_3R_619() {
33880 if (jj_scan_token(IN)) return true;
33881 Token xsp;
33882 xsp = jj_scanpos;
33883 if (jj_scan_token(207)) jj_scanpos = xsp;
33884 return false;
33885 }
33886
33887 private boolean jj_3R_594() {
33888 Token xsp;
33889 xsp = jj_scanpos;
33890 if (jj_3R_619()) {
33891 jj_scanpos = xsp;
33892 if (jj_scan_token(207)) return true;
33893 }
33894 return false;
33895 }
33896
33897 private boolean jj_3R_554() {
33898 if (jj_scan_token(BULK)) return true;
33899 if (jj_scan_token(COLLECT)) return true;
33900 return false;
33901 }
33902
33903 private boolean jj_3R_555() {
33904 if (jj_scan_token(6)) return true;
33905 if (jj_3R_234()) return true;
33906 return false;
33907 }
33908
33909 private boolean jj_3R_420() {
33910 if (jj_scan_token(PIPE)) return true;
33911 if (jj_scan_token(ROW)) return true;
33912 if (jj_3R_234()) return true;
33913 return false;
33914 }
33915
33916 private boolean jj_3R_593() {
33917 if (jj_scan_token(USING)) return true;
33918 Token xsp;
33919 xsp = jj_scanpos;
33920 if (jj_3R_618()) jj_scanpos = xsp;
33921 if (jj_3R_234()) return true;
33922 while (true) {
33923 xsp = jj_scanpos;
33924 if (jj_3R_643()) { jj_scanpos = xsp; break; }
33925 }
33926 return false;
33927 }
33928
33929 private boolean jj_3R_559() {
33930 Token xsp;
33931 xsp = jj_scanpos;
33932 if (jj_scan_token(237)) {
33933 jj_scanpos = xsp;
33934 if (jj_scan_token(238)) return true;
33935 }
33936 if (jj_scan_token(INTO)) return true;
33937 if (jj_3R_234()) return true;
33938 while (true) {
33939 xsp = jj_scanpos;
33940 if (jj_3R_641()) { jj_scanpos = xsp; break; }
33941 }
33942 return false;
33943 }
33944
33945 private boolean jj_3R_558() {
33946 if (jj_scan_token(USING)) return true;
33947 Token xsp;
33948 xsp = jj_scanpos;
33949 if (jj_3R_594()) jj_scanpos = xsp;
33950 if (jj_3R_234()) return true;
33951 while (true) {
33952 xsp = jj_scanpos;
33953 if (jj_3R_640()) { jj_scanpos = xsp; break; }
33954 }
33955 return false;
33956 }
33957
33958 private boolean jj_3R_352() {
33959 if (jj_scan_token(PRAGMA)) return true;
33960 Token xsp;
33961 xsp = jj_scanpos;
33962 if (jj_scan_token(38)) {
33963 jj_scanpos = xsp;
33964 if (jj_scan_token(41)) {
33965 jj_scanpos = xsp;
33966 if (jj_3R_402()) {
33967 jj_scanpos = xsp;
33968 if (jj_3R_403()) {
33969 jj_scanpos = xsp;
33970 if (jj_3R_404()) return true;
33971 }
33972 }
33973 }
33974 }
33975 return false;
33976 }
33977
33978 private boolean jj_3R_557() {
33979 if (jj_scan_token(INTO)) return true;
33980 if (jj_3R_295()) return true;
33981 Token xsp;
33982 while (true) {
33983 xsp = jj_scanpos;
33984 if (jj_3R_639()) { jj_scanpos = xsp; break; }
33985 }
33986 return false;
33987 }
33988
33989 private boolean jj_3R_452() {
33990 if (jj_scan_token(WHEN)) return true;
33991 if (jj_3R_234()) return true;
33992 return false;
33993 }
33994
33995 private boolean jj_3R_419() {
33996 if (jj_scan_token(EXECUTE)) return true;
33997 if (jj_scan_token(IMMEDIATE)) return true;
33998 if (jj_3R_234()) return true;
33999 Token xsp;
34000 xsp = jj_scanpos;
34001 if (jj_3R_557()) jj_scanpos = xsp;
34002 xsp = jj_scanpos;
34003 if (jj_3R_558()) jj_scanpos = xsp;
34004 xsp = jj_scanpos;
34005 if (jj_3R_559()) jj_scanpos = xsp;
34006 if (jj_scan_token(4)) return true;
34007 return false;
34008 }
34009
34010 private boolean jj_3R_455() {
34011 if (jj_scan_token(FOR)) return true;
34012 if (jj_3R_234()) return true;
34013 Token xsp;
34014 xsp = jj_scanpos;
34015 if (jj_3R_593()) jj_scanpos = xsp;
34016 return false;
34017 }
34018
34019 private boolean jj_3R_418() {
34020 if (jj_scan_token(FETCH)) return true;
34021 if (jj_3R_128()) return true;
34022 Token xsp;
34023 xsp = jj_scanpos;
34024 if (jj_3R_554()) jj_scanpos = xsp;
34025 if (jj_scan_token(INTO)) return true;
34026 if (jj_3R_234()) return true;
34027 while (true) {
34028 xsp = jj_scanpos;
34029 if (jj_3R_555()) { jj_scanpos = xsp; break; }
34030 }
34031 xsp = jj_scanpos;
34032 if (jj_3R_556()) jj_scanpos = xsp;
34033 return false;
34034 }
34035
34036 private boolean jj_3R_209() {
34037 if (jj_scan_token(WHEN)) return true;
34038 if (jj_3R_234()) return true;
34039 return false;
34040 }
34041
34042 private boolean jj_3R_454() {
34043 if (jj_3R_234()) return true;
34044 return false;
34045 }
34046
34047 private boolean jj_3R_148() {
34048 if (jj_3R_124()) return true;
34049 if (jj_3R_236()) return true;
34050 return false;
34051 }
34052
34053 private boolean jj_3R_417() {
34054 if (jj_scan_token(OPEN)) return true;
34055 Token xsp;
34056 xsp = jj_scanpos;
34057 if (jj_3R_454()) jj_scanpos = xsp;
34058 xsp = jj_scanpos;
34059 if (jj_3R_455()) jj_scanpos = xsp;
34060 return false;
34061 }
34062
34063 private boolean jj_3R_453() {
34064 if (jj_3R_128()) return true;
34065 return false;
34066 }
34067
34068 private boolean jj_3R_416() {
34069 if (jj_scan_token(CLOSE)) return true;
34070 if (jj_3R_128()) return true;
34071 return false;
34072 }
34073
34074 private boolean jj_3R_451() {
34075 if (jj_3R_143()) return true;
34076 return false;
34077 }
34078
34079 private boolean jj_3R_415() {
34080 if (jj_scan_token(RAISE)) return true;
34081 Token xsp;
34082 xsp = jj_scanpos;
34083 if (jj_3R_453()) jj_scanpos = xsp;
34084 return false;
34085 }
34086
34087 private boolean jj_3R_208() {
34088 if (jj_3R_143()) return true;
34089 return false;
34090 }
34091
34092 private boolean jj_3R_592() {
34093 if (jj_scan_token(12)) return true;
34094 if (jj_3R_234()) return true;
34095 return false;
34096 }
34097
34098 private boolean jj_3R_414() {
34099 if (jj_scan_token(EXIT)) return true;
34100 Token xsp;
34101 xsp = jj_scanpos;
34102 if (jj_3R_451()) jj_scanpos = xsp;
34103 xsp = jj_scanpos;
34104 if (jj_3R_452()) jj_scanpos = xsp;
34105 return false;
34106 }
34107
34108 private boolean jj_3R_450() {
34109 if (jj_3R_234()) return true;
34110 return false;
34111 }
34112
34113 private boolean jj_3R_132() {
34114 if (jj_scan_token(CONTINUE)) return true;
34115 Token xsp;
34116 xsp = jj_scanpos;
34117 if (jj_3R_208()) jj_scanpos = xsp;
34118 xsp = jj_scanpos;
34119 if (jj_3R_209()) jj_scanpos = xsp;
34120 return false;
34121 }
34122
34123 private boolean jj_3R_552() {
34124 if (jj_scan_token(SAVE)) return true;
34125 if (jj_scan_token(EXCEPTIONS)) return true;
34126 return false;
34127 }
34128
34129 private boolean jj_3R_551() {
34130 if (jj_3R_234()) return true;
34131 Token xsp;
34132 xsp = jj_scanpos;
34133 if (jj_3R_592()) jj_scanpos = xsp;
34134 return false;
34135 }
34136
34137 private boolean jj_3R_638() {
34138 if (jj_3R_174()) return true;
34139 return false;
34140 }
34141
34142 private boolean jj_3R_550() {
34143 Token xsp;
34144 xsp = jj_scanpos;
34145 if (jj_scan_token(140)) {
34146 jj_scanpos = xsp;
34147 if (jj_scan_token(289)) return true;
34148 }
34149 if (jj_scan_token(OF)) return true;
34150 if (jj_3R_234()) return true;
34151 return false;
34152 }
34153
34154 private boolean jj_3R_413() {
34155 if (jj_scan_token(RETURN)) return true;
34156 Token xsp;
34157 xsp = jj_scanpos;
34158 if (jj_3R_450()) jj_scanpos = xsp;
34159 return false;
34160 }
34161
34162 private boolean jj_3R_412() {
34163 if (jj_scan_token(GOTO)) return true;
34164 if (jj_3R_128()) return true;
34165 return false;
34166 }
34167
34168 private boolean jj_3R_356() {
34169 if (jj_scan_token(CASCADE)) return true;
34170 return false;
34171 }
34172
34173 private boolean jj_3R_315() {
34174 Token xsp;
34175 xsp = jj_scanpos;
34176 if (jj_scan_token(151)) {
34177 jj_scanpos = xsp;
34178 if (jj_3R_356()) return true;
34179 }
34180 return false;
34181 }
34182
34183 private boolean jj_3R_150() {
34184 if (jj_3R_239()) return true;
34185 return false;
34186 }
34187
34188 private boolean jj_3R_409() {
34189 if (jj_scan_token(FORALL)) return true;
34190 if (jj_3R_448()) return true;
34191 if (jj_scan_token(IN)) return true;
34192 Token xsp;
34193 xsp = jj_scanpos;
34194 if (jj_3R_550()) {
34195 jj_scanpos = xsp;
34196 if (jj_3R_551()) return true;
34197 }
34198 xsp = jj_scanpos;
34199 if (jj_3R_552()) jj_scanpos = xsp;
34200 if (jj_3R_405()) return true;
34201 return false;
34202 }
34203
34204 private boolean jj_3_73() {
34205 if (jj_3R_147()) return true;
34206 return false;
34207 }
34208
34209 private boolean jj_3R_549() {
34210 if (jj_scan_token(12)) return true;
34211 if (jj_3R_234()) return true;
34212 return false;
34213 }
34214
34215 private boolean jj_3R_149() {
34216 if (jj_scan_token(AUTHID)) return true;
34217 Token xsp;
34218 xsp = jj_scanpos;
34219 if (jj_scan_token(37)) {
34220 jj_scanpos = xsp;
34221 if (jj_scan_token(36)) return true;
34222 }
34223 return false;
34224 }
34225
34226 private boolean jj_3R_314() {
34227 Token xsp;
34228 xsp = jj_scanpos;
34229 if (jj_scan_token(183)) jj_scanpos = xsp;
34230 xsp = jj_scanpos;
34231 if (jj_scan_token(119)) {
34232 jj_scanpos = xsp;
34233 if (jj_scan_token(145)) {
34234 jj_scanpos = xsp;
34235 if (jj_scan_token(185)) return true;
34236 }
34237 }
34238 return false;
34239 }
34240
34241 private boolean jj_3_72() {
34242 if (jj_3R_147()) return true;
34243 return false;
34244 }
34245
34246 private boolean jj_3R_546() {
34247 if (jj_3R_174()) return true;
34248 return false;
34249 }
34250
34251 private boolean jj_3R_553() {
34252 if (jj_3R_174()) return true;
34253 return false;
34254 }
34255
34256 private boolean jj_3R_448() {
34257 if (jj_3R_124()) return true;
34258 return false;
34259 }
34260
34261 private boolean jj_3_71() {
34262 Token xsp;
34263 xsp = jj_scanpos;
34264 if (jj_3R_149()) {
34265 jj_scanpos = xsp;
34266 if (jj_3R_150()) return true;
34267 }
34268 return false;
34269 }
34270
34271 private boolean jj_3R_313() {
34272 if (jj_scan_token(REPLACE)) return true;
34273 return false;
34274 }
34275
34276 private boolean jj_3R_447() {
34277 if (jj_3R_124()) return true;
34278 return false;
34279 }
34280
34281 private boolean jj_3R_548() {
34282 if (jj_3R_486()) return true;
34283 return false;
34284 }
34285
34286 private boolean jj_3R_547() {
34287 if (jj_3R_591()) return true;
34288 return false;
34289 }
34290
34291 private boolean jj_3R_407() {
34292 if (jj_scan_token(IF)) return true;
34293 if (jj_3R_234()) return true;
34294 if (jj_scan_token(THEN)) return true;
34295 Token xsp;
34296 if (jj_3R_546()) return true;
34297 while (true) {
34298 xsp = jj_scanpos;
34299 if (jj_3R_546()) { jj_scanpos = xsp; break; }
34300 }
34301 while (true) {
34302 xsp = jj_scanpos;
34303 if (jj_3R_547()) { jj_scanpos = xsp; break; }
34304 }
34305 xsp = jj_scanpos;
34306 if (jj_3R_548()) jj_scanpos = xsp;
34307 if (jj_scan_token(END)) return true;
34308 if (jj_scan_token(IF)) return true;
34309 return false;
34310 }
34311
34312 private boolean jj_3R_642() {
34313 if (jj_3R_174()) return true;
34314 return false;
34315 }
34316
34317 private boolean jj_3R_411() {
34318 if (jj_scan_token(WHILE)) return true;
34319 if (jj_3R_234()) return true;
34320 if (jj_scan_token(LOOP)) return true;
34321 Token xsp;
34322 if (jj_3R_553()) return true;
34323 while (true) {
34324 xsp = jj_scanpos;
34325 if (jj_3R_553()) { jj_scanpos = xsp; break; }
34326 }
34327 if (jj_scan_token(END)) return true;
34328 if (jj_scan_token(LOOP)) return true;
34329 xsp = jj_scanpos;
34330 if (jj_scan_token(420)) jj_scanpos = xsp;
34331 return false;
34332 }
34333
34334 private boolean jj_3R_131() {
34335 if (jj_scan_token(LOCK)) return true;
34336 if (jj_scan_token(TABLE)) return true;
34337 return false;
34338 }
34339
34340 private boolean jj_3R_408() {
34341 if (jj_scan_token(FOR)) return true;
34342 if (jj_3R_447()) return true;
34343 if (jj_scan_token(IN)) return true;
34344 Token xsp;
34345 xsp = jj_scanpos;
34346 if (jj_scan_token(239)) jj_scanpos = xsp;
34347 if (jj_3R_234()) return true;
34348 xsp = jj_scanpos;
34349 if (jj_3R_549()) jj_scanpos = xsp;
34350 if (jj_scan_token(LOOP)) return true;
34351 if (jj_3R_638()) return true;
34352 while (true) {
34353 xsp = jj_scanpos;
34354 if (jj_3R_638()) { jj_scanpos = xsp; break; }
34355 }
34356 if (jj_scan_token(END)) return true;
34357 if (jj_scan_token(LOOP)) return true;
34358 xsp = jj_scanpos;
34359 if (jj_scan_token(420)) jj_scanpos = xsp;
34360 return false;
34361 }
34362
34363 private boolean jj_3R_616() {
34364 if (jj_3R_174()) return true;
34365 return false;
34366 }
34367
34368 private boolean jj_3R_449() {
34369 if (jj_3R_174()) return true;
34370 return false;
34371 }
34372
34373 private boolean jj_3R_410() {
34374 if (jj_scan_token(LOOP)) return true;
34375 Token xsp;
34376 if (jj_3R_449()) return true;
34377 while (true) {
34378 xsp = jj_scanpos;
34379 if (jj_3R_449()) { jj_scanpos = xsp; break; }
34380 }
34381 if (jj_scan_token(END)) return true;
34382 if (jj_scan_token(LOOP)) return true;
34383 xsp = jj_scanpos;
34384 if (jj_scan_token(420)) jj_scanpos = xsp;
34385 return false;
34386 }
34387
34388 private boolean jj_3R_130() {
34389 if (jj_scan_token(SET)) return true;
34390 if (jj_scan_token(TRANSACTION)) return true;
34391 return false;
34392 }
34393
34394 private boolean jj_3R_617() {
34395 if (jj_3R_174()) return true;
34396 return false;
34397 }
34398
34399 private boolean jj_3R_591() {
34400 if (jj_scan_token(ELSIF)) return true;
34401 if (jj_3R_234()) return true;
34402 if (jj_scan_token(THEN)) return true;
34403 Token xsp;
34404 if (jj_3R_642()) return true;
34405 while (true) {
34406 xsp = jj_scanpos;
34407 if (jj_3R_642()) { jj_scanpos = xsp; break; }
34408 }
34409 return false;
34410 }
34411
34412 private boolean jj_3R_486() {
34413 if (jj_scan_token(ELSE)) return true;
34414 Token xsp;
34415 if (jj_3R_617()) return true;
34416 while (true) {
34417 xsp = jj_scanpos;
34418 if (jj_3R_617()) { jj_scanpos = xsp; break; }
34419 }
34420 return false;
34421 }
34422
34423 private boolean jj_3R_485() {
34424 if (jj_scan_token(WHEN)) return true;
34425 if (jj_3R_234()) return true;
34426 if (jj_scan_token(THEN)) return true;
34427 Token xsp;
34428 if (jj_3R_616()) return true;
34429 while (true) {
34430 xsp = jj_scanpos;
34431 if (jj_3R_616()) { jj_scanpos = xsp; break; }
34432 }
34433 return false;
34434 }
34435
34436 private boolean jj_3R_444() {
34437 if (jj_3R_234()) return true;
34438 return false;
34439 }
34440
34441 private boolean jj_3R_355() {
34442 if (jj_scan_token(DROP)) return true;
34443 return false;
34444 }
34445
34446 private boolean jj_3R_446() {
34447 if (jj_3R_486()) return true;
34448 return false;
34449 }
34450
34451 private boolean jj_3R_445() {
34452 if (jj_3R_485()) return true;
34453 return false;
34454 }
34455
34456 private boolean jj_3R_406() {
34457 if (jj_scan_token(CASE)) return true;
34458 Token xsp;
34459 xsp = jj_scanpos;
34460 if (jj_3R_444()) jj_scanpos = xsp;
34461 while (true) {
34462 xsp = jj_scanpos;
34463 if (jj_3R_445()) { jj_scanpos = xsp; break; }
34464 }
34465 xsp = jj_scanpos;
34466 if (jj_3R_446()) jj_scanpos = xsp;
34467 if (jj_scan_token(END)) return true;
34468 if (jj_scan_token(CASE)) return true;
34469 xsp = jj_scanpos;
34470 if (jj_scan_token(420)) jj_scanpos = xsp;
34471 return false;
34472 }
34473
34474 private boolean jj_3R_357() {
34475 if (jj_3R_191()) return true;
34476 return false;
34477 }
34478
34479 private boolean jj_3R_354() {
34480 Token xsp;
34481 xsp = jj_scanpos;
34482 if (jj_scan_token(6)) jj_scanpos = xsp;
34483 xsp = jj_scanpos;
34484 if (jj_scan_token(44)) {
34485 jj_scanpos = xsp;
34486 if (jj_scan_token(170)) return true;
34487 }
34488 return false;
34489 }
34490
34491 private boolean jj_3R_312() {
34492 Token xsp;
34493 xsp = jj_scanpos;
34494 if (jj_3R_354()) {
34495 jj_scanpos = xsp;
34496 if (jj_3R_355()) return true;
34497 }
34498 return false;
34499 }
34500
34501 private boolean jj_3R_316() {
34502 Token xsp;
34503 if (jj_3R_357()) return true;
34504 while (true) {
34505 xsp = jj_scanpos;
34506 if (jj_3R_357()) { jj_scanpos = xsp; break; }
34507 }
34508 if (jj_3R_317()) return true;
34509 return false;
34510 }
34511
34512 private boolean jj_3R_308() {
34513 if (jj_3R_148()) return true;
34514 return false;
34515 }
34516
34517 private boolean jj_3R_260() {
34518 if (jj_scan_token(ALTER)) return true;
34519 if (jj_scan_token(TYPE)) return true;
34520 if (jj_3R_128()) return true;
34521 Token xsp;
34522 while (true) {
34523 xsp = jj_scanpos;
34524 if (jj_3R_312()) { jj_scanpos = xsp; break; }
34525 }
34526 xsp = jj_scanpos;
34527 if (jj_3R_313()) jj_scanpos = xsp;
34528 while (true) {
34529 xsp = jj_scanpos;
34530 if (jj_3R_314()) { jj_scanpos = xsp; break; }
34531 }
34532 xsp = jj_scanpos;
34533 if (jj_3R_315()) jj_scanpos = xsp;
34534 return false;
34535 }
34536
34537 private boolean jj_3_70() {
34538 if (jj_3R_148()) return true;
34539 return false;
34540 }
34541
34542 private boolean jj_3R_265() {
34543 if (jj_3R_317()) return true;
34544 return false;
34545 }
34546
34547 private boolean jj_3R_264() {
34548 if (jj_3R_316()) return true;
34549 return false;
34550 }
34551
34552 private boolean jj_3R_261() {
34553 if (jj_3R_260()) return true;
34554 return false;
34555 }
34556
34557 private boolean jj_3R_174() {
34558 Token xsp;
34559 xsp = jj_scanpos;
34560 if (jj_3R_264()) {
34561 jj_scanpos = xsp;
34562 if (jj_3R_265()) return true;
34563 }
34564 return false;
34565 }
34566
34567 private boolean jj_3R_168() {
34568 Token xsp;
34569 xsp = jj_scanpos;
34570 if (jj_scan_token(4)) {
34571 jj_scanpos = xsp;
34572 if (jj_scan_token(1)) return true;
34573 }
34574 while (true) {
34575 xsp = jj_scanpos;
34576 if (jj_3R_261()) { jj_scanpos = xsp; break; }
34577 }
34578 return false;
34579 }
34580
34581 private boolean jj_3R_167() {
34582 if (jj_3R_260()) return true;
34583 return false;
34584 }
34585
34586 private boolean jj_3R_377() {
34587 if (jj_3R_234()) return true;
34588 if (jj_scan_token(4)) return true;
34589 return false;
34590 }
34591
34592 private boolean jj_3R_310() {
34593 if (jj_3R_147()) return true;
34594 return false;
34595 }
34596
34597 private boolean jj_3R_311() {
34598 if (jj_3R_352()) return true;
34599 return false;
34600 }
34601
34602 private boolean jj_3R_376() {
34603 if (jj_3R_422()) return true;
34604 if (jj_scan_token(4)) return true;
34605 return false;
34606 }
34607
34608 private boolean jj_3R_375() {
34609 if (jj_3R_421()) return true;
34610 return false;
34611 }
34612
34613 private boolean jj_3R_374() {
34614 if (jj_3R_420()) return true;
34615 if (jj_scan_token(4)) return true;
34616 return false;
34617 }
34618
34619 private boolean jj_3R_373() {
34620 if (jj_3R_419()) return true;
34621 if (jj_scan_token(4)) return true;
34622 return false;
34623 }
34624
34625 private boolean jj_3R_372() {
34626 if (jj_3R_272()) return true;
34627 if (jj_scan_token(4)) return true;
34628 return false;
34629 }
34630
34631 private boolean jj_3R_371() {
34632 if (jj_3R_418()) return true;
34633 if (jj_scan_token(4)) return true;
34634 return false;
34635 }
34636
34637 private boolean jj_3R_443() {
34638 if (jj_scan_token(LOCK)) return true;
34639 if (jj_scan_token(TABLE)) return true;
34640 return false;
34641 }
34642
34643 private boolean jj_3R_370() {
34644 if (jj_3R_417()) return true;
34645 if (jj_scan_token(4)) return true;
34646 return false;
34647 }
34648
34649 private boolean jj_3R_166() {
34650 Token xsp;
34651 xsp = jj_scanpos;
34652 if (jj_scan_token(183)) jj_scanpos = xsp;
34653 xsp = jj_scanpos;
34654 if (jj_scan_token(119)) {
34655 jj_scanpos = xsp;
34656 if (jj_scan_token(145)) {
34657 jj_scanpos = xsp;
34658 if (jj_scan_token(185)) return true;
34659 }
34660 }
34661 return false;
34662 }
34663
34664 private boolean jj_3R_259() {
34665 if (jj_scan_token(6)) return true;
34666 Token xsp;
34667 xsp = jj_scanpos;
34668 if (jj_3R_310()) {
34669 jj_scanpos = xsp;
34670 if (jj_3_70()) {
34671 jj_scanpos = xsp;
34672 if (jj_3R_311()) return true;
34673 }
34674 }
34675 return false;
34676 }
34677
34678 private boolean jj_3R_369() {
34679 if (jj_3R_416()) return true;
34680 if (jj_scan_token(4)) return true;
34681 return false;
34682 }
34683
34684 private boolean jj_3R_309() {
34685 if (jj_3R_352()) return true;
34686 return false;
34687 }
34688
34689 private boolean jj_3R_368() {
34690 if (jj_3R_415()) return true;
34691 if (jj_scan_token(4)) return true;
34692 return false;
34693 }
34694
34695 private boolean jj_3R_367() {
34696 if (jj_3R_414()) return true;
34697 if (jj_scan_token(4)) return true;
34698 return false;
34699 }
34700
34701 private boolean jj_3R_366() {
34702 if (jj_3R_413()) return true;
34703 if (jj_scan_token(4)) return true;
34704 return false;
34705 }
34706
34707 private boolean jj_3_69() {
34708 if (jj_3R_147()) return true;
34709 return false;
34710 }
34711
34712 private boolean jj_3R_258() {
34713 Token xsp;
34714 xsp = jj_scanpos;
34715 if (jj_3_69()) {
34716 jj_scanpos = xsp;
34717 if (jj_3R_308()) {
34718 jj_scanpos = xsp;
34719 if (jj_3R_309()) return true;
34720 }
34721 }
34722 return false;
34723 }
34724
34725 private boolean jj_3R_365() {
34726 if (jj_3R_412()) return true;
34727 if (jj_scan_token(4)) return true;
34728 return false;
34729 }
34730
34731 private boolean jj_3_42() {
34732 Token xsp;
34733 xsp = jj_scanpos;
34734 if (jj_3R_129()) {
34735 jj_scanpos = xsp;
34736 if (jj_scan_token(297)) {
34737 jj_scanpos = xsp;
34738 if (jj_scan_token(144)) {
34739 jj_scanpos = xsp;
34740 if (jj_scan_token(93)) {
34741 jj_scanpos = xsp;
34742 if (jj_scan_token(76)) {
34743 jj_scanpos = xsp;
34744 if (jj_scan_token(241)) {
34745 jj_scanpos = xsp;
34746 if (jj_scan_token(248)) {
34747 jj_scanpos = xsp;
34748 if (jj_scan_token(111)) {
34749 jj_scanpos = xsp;
34750 if (jj_3R_130()) {
34751 jj_scanpos = xsp;
34752 if (jj_3R_131()) {
34753 jj_scanpos = xsp;
34754 if (jj_scan_token(165)) {
34755 jj_scanpos = xsp;
34756 if (jj_scan_token(318)) return true;
34757 }
34758 }
34759 }
34760 }
34761 }
34762 }
34763 }
34764 }
34765 }
34766 }
34767 }
34768 return false;
34769 }
34770
34771 private boolean jj_3R_129() {
34772 Token xsp;
34773 xsp = jj_scanpos;
34774 if (jj_scan_token(5)) jj_scanpos = xsp;
34775 if (jj_scan_token(SELECT)) return true;
34776 return false;
34777 }
34778
34779 private boolean jj_3R_364() {
34780 if (jj_3R_411()) return true;
34781 if (jj_scan_token(4)) return true;
34782 return false;
34783 }
34784
34785 private boolean jj_3R_363() {
34786 if (jj_3R_410()) return true;
34787 if (jj_scan_token(4)) return true;
34788 return false;
34789 }
34790
34791 private boolean jj_3R_165() {
34792 if (jj_scan_token(5)) return true;
34793 Token xsp;
34794 while (true) {
34795 xsp = jj_scanpos;
34796 if (jj_3R_258()) { jj_scanpos = xsp; break; }
34797 }
34798 while (true) {
34799 xsp = jj_scanpos;
34800 if (jj_3R_259()) { jj_scanpos = xsp; break; }
34801 }
34802 if (jj_scan_token(7)) return true;
34803 return false;
34804 }
34805
34806 private boolean jj_3R_362() {
34807 if (jj_3R_409()) return true;
34808 if (jj_scan_token(4)) return true;
34809 return false;
34810 }
34811
34812 private boolean jj_3R_361() {
34813 if (jj_3R_408()) return true;
34814 if (jj_scan_token(4)) return true;
34815 return false;
34816 }
34817
34818 private boolean jj_3R_360() {
34819 if (jj_3R_407()) return true;
34820 if (jj_scan_token(4)) return true;
34821 return false;
34822 }
34823
34824 private boolean jj_3R_359() {
34825 if (jj_3R_406()) return true;
34826 if (jj_scan_token(4)) return true;
34827 return false;
34828 }
34829
34830 private boolean jj_3_43() {
34831 if (jj_3R_132()) return true;
34832 if (jj_scan_token(4)) return true;
34833 return false;
34834 }
34835
34836 private boolean jj_3R_358() {
34837 if (jj_3R_405()) return true;
34838 Token xsp;
34839 xsp = jj_scanpos;
34840 if (jj_scan_token(4)) jj_scanpos = xsp;
34841 return false;
34842 }
34843
34844 private boolean jj_3R_604() {
34845 if (jj_3R_124()) return true;
34846 return false;
34847 }
34848
34849 private boolean jj_3R_317() {
34850 Token xsp;
34851 xsp = jj_scanpos;
34852 if (jj_3R_358()) {
34853 jj_scanpos = xsp;
34854 if (jj_3_43()) {
34855 jj_scanpos = xsp;
34856 if (jj_3R_359()) {
34857 jj_scanpos = xsp;
34858 if (jj_3R_360()) {
34859 jj_scanpos = xsp;
34860 if (jj_3R_361()) {
34861 jj_scanpos = xsp;
34862 if (jj_3R_362()) {
34863 jj_scanpos = xsp;
34864 if (jj_3R_363()) {
34865 jj_scanpos = xsp;
34866 if (jj_3R_364()) {
34867 jj_scanpos = xsp;
34868 if (jj_3R_365()) {
34869 jj_scanpos = xsp;
34870 if (jj_3R_366()) {
34871 jj_scanpos = xsp;
34872 if (jj_3R_367()) {
34873 jj_scanpos = xsp;
34874 if (jj_3R_368()) {
34875 jj_scanpos = xsp;
34876 if (jj_3R_369()) {
34877 jj_scanpos = xsp;
34878 if (jj_3R_370()) {
34879 jj_scanpos = xsp;
34880 if (jj_3R_371()) {
34881 jj_scanpos = xsp;
34882 if (jj_3R_372()) {
34883 jj_scanpos = xsp;
34884 if (jj_3R_373()) {
34885 jj_scanpos = xsp;
34886 if (jj_3R_374()) {
34887 jj_scanpos = xsp;
34888 if (jj_3R_375()) {
34889 jj_scanpos = xsp;
34890 if (jj_3R_376()) {
34891 jj_scanpos = xsp;
34892 if (jj_3R_377()) return true;
34893 }
34894 }
34895 }
34896 }
34897 }
34898 }
34899 }
34900 }
34901 }
34902 }
34903 }
34904 }
34905 }
34906 }
34907 }
34908 }
34909 }
34910 }
34911 }
34912 }
34913 return false;
34914 }
34915
34916 private boolean jj_3R_164() {
34917 if (jj_3R_249()) return true;
34918 return false;
34919 }
34920
34921 private boolean jj_3R_442() {
34922 if (jj_scan_token(SET)) return true;
34923 if (jj_scan_token(TRANSACTION)) return true;
34924 return false;
34925 }
34926
34927 private boolean jj_3_67() {
34928 Token xsp;
34929 xsp = jj_scanpos;
34930 if (jj_scan_token(152)) {
34931 jj_scanpos = xsp;
34932 if (jj_scan_token(51)) return true;
34933 }
34934 if (jj_3R_146()) return true;
34935 if (jj_scan_token(OF)) return true;
34936 if (jj_3R_236()) return true;
34937 return false;
34938 }
34939
34940 private boolean jj_3R_145() {
34941 if (jj_3R_239()) return true;
34942 return false;
34943 }
34944
34945 private boolean jj_3_66() {
34946 Token xsp;
34947 xsp = jj_scanpos;
34948 if (jj_scan_token(152)) {
34949 jj_scanpos = xsp;
34950 if (jj_scan_token(51)) return true;
34951 }
34952 if (jj_scan_token(OPAQUE)) return true;
34953 if (jj_scan_token(VARYING)) return true;
34954 if (jj_scan_token(24)) return true;
34955 return false;
34956 }
34957
34958 private boolean jj_3_68() {
34959 if (jj_scan_token(EXTERNAL)) return true;
34960 if (jj_scan_token(IDENTIFIER)) return true;
34961 if (jj_scan_token(IDENTIFIER)) return true;
34962 if (jj_scan_token(LANGUAGE)) return true;
34963 if (jj_scan_token(JAVA)) return true;
34964 if (jj_scan_token(USING)) return true;
34965 if (jj_scan_token(IDENTIFIER)) return true;
34966 return false;
34967 }
34968
34969 private boolean jj_3_65() {
34970 Token xsp;
34971 xsp = jj_scanpos;
34972 if (jj_scan_token(152)) {
34973 jj_scanpos = xsp;
34974 if (jj_scan_token(51)) return true;
34975 }
34976 if (jj_scan_token(OBJECT)) return true;
34977 return false;
34978 }
34979
34980 private boolean jj_3R_144() {
34981 if (jj_scan_token(AUTHID)) return true;
34982 Token xsp;
34983 xsp = jj_scanpos;
34984 if (jj_scan_token(37)) {
34985 jj_scanpos = xsp;
34986 if (jj_scan_token(36)) return true;
34987 }
34988 return false;
34989 }
34990
34991 private boolean jj_3R_257() {
34992 if (jj_scan_token(UNDER)) return true;
34993 if (jj_3R_155()) return true;
34994 return false;
34995 }
34996
34997 private boolean jj_3R_163() {
34998 Token xsp;
34999 xsp = jj_scanpos;
35000 if (jj_3R_257()) {
35001 jj_scanpos = xsp;
35002 if (jj_3_65()) {
35003 jj_scanpos = xsp;
35004 if (jj_3_66()) {
35005 jj_scanpos = xsp;
35006 if (jj_3_67()) return true;
35007 }
35008 }
35009 }
35010 return false;
35011 }
35012
35013 private boolean jj_3R_256() {
35014 Token xsp;
35015 xsp = jj_scanpos;
35016 if (jj_scan_token(100)) {
35017 jj_scanpos = xsp;
35018 if (jj_scan_token(182)) return true;
35019 }
35020 return false;
35021 }
35022
35023 private boolean jj_3R_249() {
35024 if (jj_scan_token(WRAPPED)) return true;
35025 return false;
35026 }
35027
35028 private boolean jj_3R_603() {
35029 if (jj_3R_351()) return true;
35030 return false;
35031 }
35032
35033 private boolean jj_3_64() {
35034 Token xsp;
35035 xsp = jj_scanpos;
35036 if (jj_3R_144()) {
35037 jj_scanpos = xsp;
35038 if (jj_3R_145()) return true;
35039 }
35040 return false;
35041 }
35042
35043 private boolean jj_3_63() {
35044 if (jj_scan_token(OID)) return true;
35045 if (jj_scan_token(STRING_LITERAL)) return true;
35046 return false;
35047 }
35048
35049 private boolean jj_3R_255() {
35050 if (jj_scan_token(OR)) return true;
35051 if (jj_scan_token(REPLACE)) return true;
35052 return false;
35053 }
35054
35055 private boolean jj_3R_602() {
35056 if (jj_3R_174()) return true;
35057 return false;
35058 }
35059
35060 private boolean jj_3R_162() {
35061 if (jj_scan_token(CREATE)) return true;
35062 Token xsp;
35063 xsp = jj_scanpos;
35064 if (jj_3R_255()) jj_scanpos = xsp;
35065 xsp = jj_scanpos;
35066 if (jj_3R_256()) jj_scanpos = xsp;
35067 return false;
35068 }
35069
35070 private boolean jj_3R_105() {
35071 Token xsp;
35072 xsp = jj_scanpos;
35073 if (jj_3R_162()) jj_scanpos = xsp;
35074 if (jj_scan_token(TYPE)) return true;
35075 if (jj_3R_155()) return true;
35076 xsp = jj_scanpos;
35077 if (jj_scan_token(123)) jj_scanpos = xsp;
35078 xsp = jj_scanpos;
35079 if (jj_3_63()) jj_scanpos = xsp;
35080 while (true) {
35081 xsp = jj_scanpos;
35082 if (jj_3_64()) { jj_scanpos = xsp; break; }
35083 }
35084 xsp = jj_scanpos;
35085 if (jj_3R_163()) jj_scanpos = xsp;
35086 xsp = jj_scanpos;
35087 if (jj_3_68()) jj_scanpos = xsp;
35088 xsp = jj_scanpos;
35089 if (jj_3R_164()) jj_scanpos = xsp;
35090 xsp = jj_scanpos;
35091 if (jj_3R_165()) jj_scanpos = xsp;
35092 while (true) {
35093 xsp = jj_scanpos;
35094 if (jj_3R_166()) { jj_scanpos = xsp; break; }
35095 }
35096 while (true) {
35097 xsp = jj_scanpos;
35098 if (jj_3R_167()) { jj_scanpos = xsp; break; }
35099 }
35100 xsp = jj_scanpos;
35101 if (jj_3R_168()) jj_scanpos = xsp;
35102 return false;
35103 }
35104
35105 private boolean jj_3R_568() {
35106 if (jj_3R_192()) return true;
35107 if (jj_scan_token(BEGIN)) return true;
35108 Token xsp;
35109 while (true) {
35110 xsp = jj_scanpos;
35111 if (jj_3R_602()) { jj_scanpos = xsp; break; }
35112 }
35113 xsp = jj_scanpos;
35114 if (jj_3R_603()) jj_scanpos = xsp;
35115 if (jj_scan_token(END)) return true;
35116 xsp = jj_scanpos;
35117 if (jj_3R_604()) jj_scanpos = xsp;
35118 if (jj_scan_token(4)) return true;
35119 return false;
35120 }
35121
35122 private boolean jj_3R_567() {
35123 if (jj_3R_123()) return true;
35124 Token xsp;
35125 xsp = jj_scanpos;
35126 if (jj_scan_token(4)) jj_scanpos = xsp;
35127 return false;
35128 }
35129
35130 private boolean jj_3R_531() {
35131 Token xsp;
35132 xsp = jj_scanpos;
35133 if (jj_scan_token(152)) {
35134 jj_scanpos = xsp;
35135 if (jj_scan_token(51)) return true;
35136 }
35137 xsp = jj_scanpos;
35138 if (jj_3R_567()) {
35139 jj_scanpos = xsp;
35140 if (jj_3R_568()) return true;
35141 }
35142 return false;
35143 }
35144
35145 private boolean jj_3R_405() {
35146 Token xsp;
35147 xsp = jj_scanpos;
35148 if (jj_scan_token(250)) {
35149 jj_scanpos = xsp;
35150 if (jj_scan_token(297)) {
35151 jj_scanpos = xsp;
35152 if (jj_scan_token(144)) {
35153 jj_scanpos = xsp;
35154 if (jj_scan_token(93)) {
35155 jj_scanpos = xsp;
35156 if (jj_scan_token(76)) {
35157 jj_scanpos = xsp;
35158 if (jj_scan_token(241)) {
35159 jj_scanpos = xsp;
35160 if (jj_scan_token(248)) {
35161 jj_scanpos = xsp;
35162 if (jj_scan_token(111)) {
35163 jj_scanpos = xsp;
35164 if (jj_3R_442()) {
35165 jj_scanpos = xsp;
35166 if (jj_3R_443()) {
35167 jj_scanpos = xsp;
35168 if (jj_scan_token(165)) {
35169 jj_scanpos = xsp;
35170 if (jj_scan_token(318)) return true;
35171 }
35172 }
35173 }
35174 }
35175 }
35176 }
35177 }
35178 }
35179 }
35180 }
35181 }
35182 if (jj_3R_180()) return true;
35183 return false;
35184 }
35185
35186 private boolean jj_3_61() {
35187 if (jj_3R_124()) return true;
35188 if (jj_scan_token(3)) return true;
35189 return false;
35190 }
35191
35192 private boolean jj_3R_491() {
35193 return false;
35194 }
35195
35196 private boolean jj_3R_242() {
35197 Token xsp;
35198 xsp = jj_scanpos;
35199 if (jj_scan_token(162)) {
35200 jj_scanpos = xsp;
35201 if (jj_scan_token(204)) return true;
35202 }
35203 return false;
35204 }
35205
35206 private boolean jj_3R_241() {
35207 Token xsp;
35208 xsp = jj_scanpos;
35209 if (jj_scan_token(183)) jj_scanpos = xsp;
35210 xsp = jj_scanpos;
35211 if (jj_scan_token(208)) {
35212 jj_scanpos = xsp;
35213 if (jj_scan_token(145)) {
35214 jj_scanpos = xsp;
35215 if (jj_scan_token(119)) return true;
35216 }
35217 }
35218 return false;
35219 }
35220
35221 private boolean jj_3_62() {
35222 if (jj_3R_124()) return true;
35223 if (jj_scan_token(3)) return true;
35224 if (jj_3R_124()) return true;
35225 if (jj_scan_token(3)) return true;
35226 if (jj_3R_124()) return true;
35227 return false;
35228 }
35229
35230 private boolean jj_3R_147() {
35231 Token xsp;
35232 while (true) {
35233 xsp = jj_scanpos;
35234 if (jj_3R_241()) { jj_scanpos = xsp; break; }
35235 }
35236 xsp = jj_scanpos;
35237 if (jj_3R_242()) jj_scanpos = xsp;
35238 xsp = jj_scanpos;
35239 if (jj_scan_token(80)) {
35240 jj_scanpos = xsp;
35241 if (jj_scan_token(164)) {
35242 jj_scanpos = xsp;
35243 if (jj_scan_token(262)) return true;
35244 }
35245 }
35246 if (jj_3R_194()) return true;
35247 xsp = jj_scanpos;
35248 if (jj_scan_token(95)) jj_scanpos = xsp;
35249 xsp = jj_scanpos;
35250 if (jj_scan_token(210)) jj_scanpos = xsp;
35251 xsp = jj_scanpos;
35252 if (jj_scan_token(214)) jj_scanpos = xsp;
35253 xsp = jj_scanpos;
35254 if (jj_scan_token(236)) jj_scanpos = xsp;
35255 xsp = jj_scanpos;
35256 if (jj_3R_531()) jj_scanpos = xsp;
35257 return false;
35258 }
35259
35260 private boolean jj_3R_188() {
35261 return false;
35262 }
35263
35264 private boolean jj_3R_262() {
35265 if (jj_3R_124()) return true;
35266 return false;
35267 }
35268
35269 private boolean jj_3R_190() {
35270 return false;
35271 }
35272
35273 private boolean jj_3R_185() {
35274 if (jj_3R_143()) return true;
35275 if (jj_scan_token(IDENTIFIED)) return true;
35276 return false;
35277 }
35278
35279 private boolean jj_3R_184() {
35280 if (jj_scan_token(CONNECT)) return true;
35281 if (jj_scan_token(TO)) return true;
35282 return false;
35283 }
35284
35285 private boolean jj_3R_112() {
35286 if (jj_scan_token(CREATE)) return true;
35287 Token xsp;
35288 xsp = jj_scanpos;
35289 if (jj_scan_token(410)) jj_scanpos = xsp;
35290 xsp = jj_scanpos;
35291 if (jj_scan_token(224)) jj_scanpos = xsp;
35292 if (jj_scan_token(DATABASE)) return true;
35293 if (jj_scan_token(LINK)) return true;
35294 if (jj_3R_155()) return true;
35295 xsp = jj_scanpos;
35296 if (jj_3R_184()) {
35297 jj_scanpos = xsp;
35298 if (jj_3R_185()) return true;
35299 }
35300 return false;
35301 }
35302
35303 private boolean jj_3R_459() {
35304 if (jj_3R_174()) return true;
35305 return false;
35306 }
35307
35308 private boolean jj_3R_182() {
35309 if (jj_scan_token(OR)) return true;
35310 if (jj_scan_token(REPLACE)) return true;
35311 return false;
35312 }
35313
35314 private boolean jj_3R_111() {
35315 if (jj_scan_token(CREATE)) return true;
35316 Token xsp;
35317 xsp = jj_scanpos;
35318 if (jj_3R_182()) jj_scanpos = xsp;
35319 if (jj_scan_token(DIRECTORY)) return true;
35320 if (jj_3R_155()) return true;
35321 if (jj_scan_token(AS)) return true;
35322 if (jj_3R_183()) return true;
35323 xsp = jj_scanpos;
35324 if (jj_scan_token(4)) {
35325 jj_scanpos = xsp;
35326 if (jj_scan_token(1)) return true;
35327 }
35328 return false;
35329 }
35330
35331 private boolean jj_3R_181() {
35332 if (jj_scan_token(OR)) return true;
35333 if (jj_scan_token(REPLACE)) return true;
35334 return false;
35335 }
35336
35337 private boolean jj_3R_564() {
35338 return false;
35339 }
35340
35341 private boolean jj_3R_263() {
35342 if (jj_scan_token(6)) return true;
35343 return false;
35344 }
35345
35346 private boolean jj_3R_110() {
35347 if (jj_scan_token(CREATE)) return true;
35348 Token xsp;
35349 xsp = jj_scanpos;
35350 if (jj_3R_181()) jj_scanpos = xsp;
35351 xsp = jj_scanpos;
35352 if (jj_scan_token(224)) jj_scanpos = xsp;
35353 if (jj_scan_token(SYNONYM)) return true;
35354 if (jj_3R_155()) return true;
35355 if (jj_scan_token(FOR)) return true;
35356 if (jj_3R_155()) return true;
35357 xsp = jj_scanpos;
35358 if (jj_scan_token(4)) {
35359 jj_scanpos = xsp;
35360 if (jj_scan_token(1)) return true;
35361 }
35362 return false;
35363 }
35364
35365 private boolean jj_3R_458() {
35366 if (jj_scan_token(OR)) return true;
35367 if (jj_3R_128()) return true;
35368 return false;
35369 }
35370
35371 private boolean jj_3R_171() {
35372 if (jj_scan_token(OR)) return true;
35373 if (jj_scan_token(REPLACE)) return true;
35374 return false;
35375 }
35376
35377 private boolean jj_3R_173() {
35378 if (jj_scan_token(5)) return true;
35379 if (jj_3R_262()) return true;
35380 Token xsp;
35381 while (true) {
35382 xsp = jj_scanpos;
35383 if (jj_3R_263()) { jj_scanpos = xsp; break; }
35384 }
35385 if (jj_scan_token(7)) return true;
35386 return false;
35387 }
35388
35389 private boolean jj_3R_172() {
35390 Token xsp;
35391 xsp = jj_scanpos;
35392 if (jj_scan_token(179)) jj_scanpos = xsp;
35393 if (jj_scan_token(FORCE)) return true;
35394 return false;
35395 }
35396
35397 private boolean jj_3R_460() {
35398 if (jj_3R_174()) return true;
35399 return false;
35400 }
35401
35402 private boolean jj_3R_107() {
35403 if (jj_scan_token(CREATE)) return true;
35404 Token xsp;
35405 xsp = jj_scanpos;
35406 if (jj_3R_171()) jj_scanpos = xsp;
35407 xsp = jj_scanpos;
35408 if (jj_3R_172()) jj_scanpos = xsp;
35409 if (jj_scan_token(VIEW)) return true;
35410 if (jj_3R_155()) return true;
35411 xsp = jj_scanpos;
35412 if (jj_3R_173()) jj_scanpos = xsp;
35413 if (jj_scan_token(AS)) return true;
35414 if (jj_3R_174()) return true;
35415 xsp = jj_scanpos;
35416 if (jj_scan_token(4)) {
35417 jj_scanpos = xsp;
35418 if (jj_scan_token(1)) return true;
35419 }
35420 return false;
35421 }
35422
35423 private boolean jj_3R_180() {
35424 return false;
35425 }
35426
35427 private boolean jj_3R_170() {
35428 if (jj_3R_124()) return true;
35429 if (jj_3R_236()) return true;
35430 return false;
35431 }
35432
35433 private boolean jj_3R_629() {
35434 if (jj_scan_token(6)) return true;
35435 if (jj_3R_124()) return true;
35436 return false;
35437 }
35438
35439 private boolean jj_3R_628() {
35440 if (jj_scan_token(6)) return true;
35441 if (jj_3R_124()) return true;
35442 return false;
35443 }
35444
35445 private boolean jj_3R_169() {
35446 if (jj_scan_token(GLOBAL)) return true;
35447 if (jj_scan_token(TEMPORARY)) return true;
35448 return false;
35449 }
35450
35451 private boolean jj_3_60() {
35452 if (jj_scan_token(ON)) return true;
35453 if (jj_scan_token(COMMIT)) return true;
35454 return false;
35455 }
35456
35457 private boolean jj_3R_401() {
35458 if (jj_scan_token(WHEN)) return true;
35459 if (jj_scan_token(OTHERS)) return true;
35460 if (jj_scan_token(THEN)) return true;
35461 Token xsp;
35462 if (jj_3R_460()) return true;
35463 while (true) {
35464 xsp = jj_scanpos;
35465 if (jj_3R_460()) { jj_scanpos = xsp; break; }
35466 }
35467 return false;
35468 }
35469
35470 private boolean jj_3_41() {
35471 if (jj_scan_token(WHEN)) return true;
35472 if (jj_3R_128()) return true;
35473 Token xsp;
35474 while (true) {
35475 xsp = jj_scanpos;
35476 if (jj_3R_458()) { jj_scanpos = xsp; break; }
35477 }
35478 if (jj_scan_token(THEN)) return true;
35479 if (jj_3R_459()) return true;
35480 while (true) {
35481 xsp = jj_scanpos;
35482 if (jj_3R_459()) { jj_scanpos = xsp; break; }
35483 }
35484 return false;
35485 }
35486
35487 private boolean jj_3R_106() {
35488 if (jj_scan_token(CREATE)) return true;
35489 Token xsp;
35490 xsp = jj_scanpos;
35491 if (jj_3R_169()) jj_scanpos = xsp;
35492 if (jj_scan_token(TABLE)) return true;
35493 if (jj_3R_155()) return true;
35494 if (jj_scan_token(5)) return true;
35495 if (jj_3R_170()) return true;
35496 return false;
35497 }
35498
35499 private boolean jj_3R_621() {
35500 Token xsp;
35501 xsp = jj_scanpos;
35502 if (jj_scan_token(125)) {
35503 jj_scanpos = xsp;
35504 if (jj_scan_token(223)) {
35505 jj_scanpos = xsp;
35506 if (jj_scan_token(209)) {
35507 jj_scanpos = xsp;
35508 if (jj_scan_token(282)) {
35509 jj_scanpos = xsp;
35510 if (jj_scan_token(284)) return true;
35511 }
35512 }
35513 }
35514 }
35515 return false;
35516 }
35517
35518 private boolean jj_3R_351() {
35519 if (jj_scan_token(EXCEPTION)) return true;
35520 Token xsp;
35521 while (true) {
35522 xsp = jj_scanpos;
35523 if (jj_3_41()) { jj_scanpos = xsp; break; }
35524 }
35525 xsp = jj_scanpos;
35526 if (jj_3R_401()) jj_scanpos = xsp;
35527 return false;
35528 }
35529
35530 private boolean jj_3R_349() {
35531 Token xsp;
35532 xsp = jj_scanpos;
35533 if (jj_scan_token(125)) {
35534 jj_scanpos = xsp;
35535 if (jj_scan_token(223)) {
35536 jj_scanpos = xsp;
35537 if (jj_scan_token(209)) {
35538 jj_scanpos = xsp;
35539 if (jj_scan_token(282)) {
35540 jj_scanpos = xsp;
35541 if (jj_scan_token(284)) return true;
35542 }
35543 }
35544 }
35545 }
35546 return false;
35547 }
35548
35549 private boolean jj_3R_350() {
35550 if (jj_scan_token(6)) return true;
35551 Token xsp;
35552 xsp = jj_scanpos;
35553 if (jj_3R_621()) jj_scanpos = xsp;
35554 if (jj_3R_128()) return true;
35555 return false;
35556 }
35557
35558 private boolean jj_3R_490() {
35559 if (jj_scan_token(6)) return true;
35560 if (jj_3R_127()) return true;
35561 return false;
35562 }
35563
35564 private boolean jj_3R_489() {
35565 Token xsp;
35566 xsp = jj_scanpos;
35567 if (jj_scan_token(16)) {
35568 jj_scanpos = xsp;
35569 if (jj_scan_token(17)) return true;
35570 }
35571 return false;
35572 }
35573
35574 private boolean jj_3R_239() {
35575 if (jj_scan_token(ACCESSIBLE)) return true;
35576 if (jj_scan_token(BY)) return true;
35577 if (jj_scan_token(5)) return true;
35578 Token xsp;
35579 xsp = jj_scanpos;
35580 if (jj_3R_349()) jj_scanpos = xsp;
35581 if (jj_3R_128()) return true;
35582 while (true) {
35583 xsp = jj_scanpos;
35584 if (jj_3R_350()) { jj_scanpos = xsp; break; }
35585 }
35586 if (jj_scan_token(7)) return true;
35587 return false;
35588 }
35589
35590 private boolean jj_3R_622() {
35591 Token xsp;
35592 xsp = jj_scanpos;
35593 if (jj_scan_token(130)) {
35594 jj_scanpos = xsp;
35595 if (jj_scan_token(226)) return true;
35596 }
35597 if (jj_scan_token(5)) return true;
35598 if (jj_3R_124()) return true;
35599 while (true) {
35600 xsp = jj_scanpos;
35601 if (jj_3R_628()) { jj_scanpos = xsp; break; }
35602 }
35603 if (jj_scan_token(7)) return true;
35604 return false;
35605 }
35606
35607 private boolean jj_3_40() {
35608 if (jj_scan_token(5)) return true;
35609 if (jj_3R_127()) return true;
35610 if (jj_scan_token(7)) return true;
35611 return false;
35612 }
35613
35614 private boolean jj_3R_623() {
35615 Token xsp;
35616 xsp = jj_scanpos;
35617 if (jj_scan_token(204)) {
35618 jj_scanpos = xsp;
35619 if (jj_scan_token(71)) return true;
35620 }
35621 if (jj_scan_token(BY)) return true;
35622 if (jj_scan_token(5)) return true;
35623 if (jj_3R_124()) return true;
35624 while (true) {
35625 xsp = jj_scanpos;
35626 if (jj_3R_629()) { jj_scanpos = xsp; break; }
35627 }
35628 if (jj_scan_token(7)) return true;
35629 return false;
35630 }
35631
35632 private boolean jj_3R_481() {
35633 if (jj_scan_token(TO)) return true;
35634 Token xsp;
35635 xsp = jj_scanpos;
35636 if (jj_scan_token(316)) {
35637 jj_scanpos = xsp;
35638 if (jj_scan_token(173)) {
35639 jj_scanpos = xsp;
35640 if (jj_scan_token(89)) {
35641 jj_scanpos = xsp;
35642 if (jj_scan_token(133)) {
35643 jj_scanpos = xsp;
35644 if (jj_scan_token(168)) {
35645 jj_scanpos = xsp;
35646 if (jj_scan_token(249)) return true;
35647 }
35648 }
35649 }
35650 }
35651 }
35652 xsp = jj_scanpos;
35653 if (jj_3_40()) jj_scanpos = xsp;
35654 return false;
35655 }
35656
35657 private boolean jj_3R_507() {
35658 if (jj_scan_token(LOCAL)) return true;
35659 return false;
35660 }
35661
35662 private boolean jj_3R_429() {
35663 if (jj_scan_token(5)) return true;
35664 if (jj_scan_token(PARTITION)) return true;
35665 if (jj_3R_124()) return true;
35666 if (jj_scan_token(BY)) return true;
35667 Token xsp;
35668 xsp = jj_scanpos;
35669 if (jj_scan_token(49)) {
35670 jj_scanpos = xsp;
35671 if (jj_3R_622()) return true;
35672 }
35673 if (jj_scan_token(7)) return true;
35674 xsp = jj_scanpos;
35675 if (jj_3R_623()) jj_scanpos = xsp;
35676 return false;
35677 }
35678
35679 private boolean jj_3R_480() {
35680 if (jj_scan_token(WITH)) return true;
35681 Token xsp;
35682 xsp = jj_scanpos;
35683 if (jj_3R_507()) jj_scanpos = xsp;
35684 if (jj_scan_token(TIME)) return true;
35685 if (jj_scan_token(ZONE)) return true;
35686 return false;
35687 }
35688
35689 private boolean jj_3R_435() {
35690 Token xsp;
35691 xsp = jj_scanpos;
35692 if (jj_3R_480()) {
35693 jj_scanpos = xsp;
35694 if (jj_3R_481()) return true;
35695 }
35696 return false;
35697 }
35698
35699 private boolean jj_3R_119() {
35700 if (jj_3R_124()) return true;
35701 if (jj_scan_token(EXCEPTION)) return true;
35702 if (jj_scan_token(4)) return true;
35703 return false;
35704 }
35705
35706 private boolean jj_3_39() {
35707 if (jj_scan_token(5)) return true;
35708 if (jj_3R_127()) return true;
35709 if (jj_scan_token(7)) return true;
35710 return false;
35711 }
35712
35713 private boolean jj_3R_519() {
35714 if (jj_3R_183()) return true;
35715 return false;
35716 }
35717
35718 private boolean jj_3R_422() {
35719 if (jj_scan_token(PRAGMA)) return true;
35720 if (jj_scan_token(INLINE)) return true;
35721 if (jj_scan_token(5)) return true;
35722 if (jj_3R_128()) return true;
35723 if (jj_scan_token(6)) return true;
35724 if (jj_3R_183()) return true;
35725 if (jj_scan_token(7)) return true;
35726 return false;
35727 }
35728
35729 private boolean jj_3R_518() {
35730 if (jj_3R_124()) return true;
35731 return false;
35732 }
35733
35734 private boolean jj_3R_469() {
35735 if (jj_3R_128()) return true;
35736 if (jj_scan_token(5)) return true;
35737 if (jj_3R_491()) return true;
35738 return false;
35739 }
35740
35741 private boolean jj_3R_468() {
35742 if (jj_scan_token(INTERFACE)) return true;
35743 if (jj_scan_token(5)) return true;
35744 if (jj_scan_token(IDENTIFIER)) return true;
35745 if (jj_scan_token(6)) return true;
35746 if (jj_3R_124()) return true;
35747 Token xsp;
35748 xsp = jj_scanpos;
35749 if (jj_3R_490()) jj_scanpos = xsp;
35750 if (jj_scan_token(7)) return true;
35751 return false;
35752 }
35753
35754 private boolean jj_3R_434() {
35755 Token xsp;
35756 xsp = jj_scanpos;
35757 if (jj_scan_token(316)) {
35758 jj_scanpos = xsp;
35759 if (jj_scan_token(173)) {
35760 jj_scanpos = xsp;
35761 if (jj_scan_token(89)) {
35762 jj_scanpos = xsp;
35763 if (jj_scan_token(133)) {
35764 jj_scanpos = xsp;
35765 if (jj_scan_token(168)) {
35766 jj_scanpos = xsp;
35767 if (jj_scan_token(249)) return true;
35768 }
35769 }
35770 }
35771 }
35772 }
35773 return false;
35774 }
35775
35776 private boolean jj_3R_467() {
35777 if (jj_scan_token(EXCEPTION_INIT)) return true;
35778 if (jj_scan_token(5)) return true;
35779 if (jj_scan_token(IDENTIFIER)) return true;
35780 if (jj_scan_token(6)) return true;
35781 Token xsp;
35782 xsp = jj_scanpos;
35783 if (jj_3R_489()) jj_scanpos = xsp;
35784 if (jj_3R_127()) return true;
35785 if (jj_scan_token(7)) return true;
35786 return false;
35787 }
35788
35789 private boolean jj_3R_488() {
35790 if (jj_scan_token(6)) return true;
35791 Token xsp;
35792 xsp = jj_scanpos;
35793 if (jj_3R_518()) {
35794 jj_scanpos = xsp;
35795 if (jj_3R_519()) return true;
35796 }
35797 return false;
35798 }
35799
35800 private boolean jj_3R_433() {
35801 if (jj_3R_183()) return true;
35802 return false;
35803 }
35804
35805 private boolean jj_3R_466() {
35806 if (jj_scan_token(RESTRICT_REFERENCES)) return true;
35807 if (jj_scan_token(5)) return true;
35808 if (jj_3R_124()) return true;
35809 Token xsp;
35810 if (jj_3R_488()) return true;
35811 while (true) {
35812 xsp = jj_scanpos;
35813 if (jj_3R_488()) { jj_scanpos = xsp; break; }
35814 }
35815 if (jj_scan_token(7)) return true;
35816 return false;
35817 }
35818
35819 private boolean jj_3R_432() {
35820 if (jj_scan_token(CHARACTER_LITERAL)) return true;
35821 return false;
35822 }
35823
35824 private boolean jj_3R_465() {
35825 if (jj_scan_token(TIMESTAMP)) return true;
35826 if (jj_scan_token(5)) return true;
35827 if (jj_3R_183()) return true;
35828 if (jj_scan_token(7)) return true;
35829 return false;
35830 }
35831
35832 private boolean jj_3R_423() {
35833 if (jj_scan_token(PRAGMA)) return true;
35834 Token xsp;
35835 xsp = jj_scanpos;
35836 if (jj_scan_token(38)) {
35837 jj_scanpos = xsp;
35838 if (jj_scan_token(41)) {
35839 jj_scanpos = xsp;
35840 if (jj_3R_465()) {
35841 jj_scanpos = xsp;
35842 if (jj_3R_466()) {
35843 jj_scanpos = xsp;
35844 if (jj_3R_467()) {
35845 jj_scanpos = xsp;
35846 if (jj_3R_468()) {
35847 jj_scanpos = xsp;
35848 if (jj_3R_469()) return true;
35849 }
35850 }
35851 }
35852 }
35853 }
35854 }
35855 if (jj_scan_token(4)) return true;
35856 return false;
35857 }
35858
35859 private boolean jj_3_34() {
35860 if (jj_scan_token(5)) return true;
35861 if (jj_3R_127()) return true;
35862 if (jj_scan_token(7)) return true;
35863 return false;
35864 }
35865
35866 private boolean jj_3R_393() {
35867 Token xsp;
35868 xsp = jj_scanpos;
35869 if (jj_scan_token(149)) {
35870 jj_scanpos = xsp;
35871 if (jj_scan_token(275)) {
35872 jj_scanpos = xsp;
35873 if (jj_scan_token(88)) return true;
35874 }
35875 }
35876 xsp = jj_scanpos;
35877 if (jj_3R_432()) {
35878 jj_scanpos = xsp;
35879 if (jj_3R_433()) return true;
35880 }
35881 xsp = jj_scanpos;
35882 if (jj_3R_434()) jj_scanpos = xsp;
35883 xsp = jj_scanpos;
35884 if (jj_3_39()) jj_scanpos = xsp;
35885 xsp = jj_scanpos;
35886 if (jj_3R_435()) jj_scanpos = xsp;
35887 return false;
35888 }
35889
35890 private boolean jj_3R_121() {
35891 if (jj_3R_198()) return true;
35892 if (jj_scan_token(4)) return true;
35893 return false;
35894 }
35895
35896 private boolean jj_3_38() {
35897 if (jj_scan_token(TO)) return true;
35898 if (jj_scan_token(SECOND)) return true;
35899 Token xsp;
35900 xsp = jj_scanpos;
35901 if (jj_3_34()) jj_scanpos = xsp;
35902 return false;
35903 }
35904
35905 private boolean jj_3R_569() {
35906 if (jj_scan_token(USING)) return true;
35907 Token xsp;
35908 xsp = jj_scanpos;
35909 if (jj_scan_token(401)) {
35910 jj_scanpos = xsp;
35911 if (jj_scan_token(402)) return true;
35912 }
35913 return false;
35914 }
35915
35916 private boolean jj_3_37() {
35917 if (jj_scan_token(TO)) return true;
35918 if (jj_scan_token(MONTH)) return true;
35919 return false;
35920 }
35921
35922 private boolean jj_3_36() {
35923 if (jj_scan_token(WITH)) return true;
35924 if (jj_scan_token(TIME)) return true;
35925 if (jj_scan_token(ZONE)) return true;
35926 return false;
35927 }
35928
35929 private boolean jj_3_35() {
35930 if (jj_scan_token(WITH)) return true;
35931 if (jj_scan_token(LOCAL)) return true;
35932 if (jj_scan_token(TIME)) return true;
35933 if (jj_scan_token(ZONE)) return true;
35934 return false;
35935 }
35936
35937 private boolean jj_3R_207() {
35938 Token xsp;
35939 xsp = jj_scanpos;
35940 if (jj_3R_291()) {
35941 jj_scanpos = xsp;
35942 if (jj_3_35()) {
35943 jj_scanpos = xsp;
35944 if (jj_3_36()) {
35945 jj_scanpos = xsp;
35946 if (jj_3_37()) {
35947 jj_scanpos = xsp;
35948 if (jj_3_38()) return true;
35949 }
35950 }
35951 }
35952 }
35953 return false;
35954 }
35955
35956 private boolean jj_3R_291() {
35957 if (jj_scan_token(CHARACTER)) return true;
35958 if (jj_scan_token(SET)) return true;
35959 if (jj_3R_295()) return true;
35960 return false;
35961 }
35962
35963 private boolean jj_3_59() {
35964 if (jj_3R_143()) return true;
35965 Token xsp;
35966 xsp = jj_scanpos;
35967 if (jj_scan_token(23)) {
35968 jj_scanpos = xsp;
35969 if (jj_scan_token(51)) return true;
35970 }
35971 return false;
35972 }
35973
35974 private boolean jj_3R_436() {
35975 Token xsp;
35976 xsp = jj_scanpos;
35977 if (jj_3_59()) jj_scanpos = xsp;
35978 if (jj_3R_234()) return true;
35979 xsp = jj_scanpos;
35980 if (jj_3R_569()) jj_scanpos = xsp;
35981 return false;
35982 }
35983
35984 private boolean jj_3R_441() {
35985 if (jj_scan_token(BYTE)) return true;
35986 return false;
35987 }
35988
35989 private boolean jj_3R_440() {
35990 if (jj_scan_token(CHAR)) return true;
35991 return false;
35992 }
35993
35994 private boolean jj_3R_439() {
35995 if (jj_scan_token(6)) return true;
35996 if (jj_3R_484()) return true;
35997 return false;
35998 }
35999
36000 private boolean jj_3R_536() {
36001 if (jj_scan_token(6)) return true;
36002 if (jj_3R_436()) return true;
36003 return false;
36004 }
36005
36006 private boolean jj_3R_394() {
36007 if (jj_3R_436()) return true;
36008 Token xsp;
36009 while (true) {
36010 xsp = jj_scanpos;
36011 if (jj_3R_536()) { jj_scanpos = xsp; break; }
36012 }
36013 return false;
36014 }
36015
36016 private boolean jj_3_33() {
36017 if (jj_scan_token(5)) return true;
36018 if (jj_3R_127()) return true;
36019 Token xsp;
36020 xsp = jj_scanpos;
36021 if (jj_3R_439()) jj_scanpos = xsp;
36022 xsp = jj_scanpos;
36023 if (jj_3R_440()) jj_scanpos = xsp;
36024 xsp = jj_scanpos;
36025 if (jj_3R_441()) jj_scanpos = xsp;
36026 if (jj_scan_token(7)) return true;
36027 return false;
36028 }
36029
36030 private boolean jj_3R_342() {
36031 if (jj_3R_394()) return true;
36032 return false;
36033 }
36034
36035 private boolean jj_3R_142() {
36036 if (jj_scan_token(11)) return true;
36037 return false;
36038 }
36039
36040 private boolean jj_3R_283() {
36041 Token xsp;
36042 xsp = jj_scanpos;
36043 if (jj_scan_token(117)) {
36044 jj_scanpos = xsp;
36045 if (jj_scan_token(283)) {
36046 jj_scanpos = xsp;
36047 if (jj_scan_token(296)) {
36048 jj_scanpos = xsp;
36049 if (jj_scan_token(377)) {
36050 jj_scanpos = xsp;
36051 if (jj_scan_token(44)) {
36052 jj_scanpos = xsp;
36053 if (jj_scan_token(321)) {
36054 jj_scanpos = xsp;
36055 if (jj_scan_token(45)) {
36056 jj_scanpos = xsp;
36057 if (jj_scan_token(344)) {
36058 jj_scanpos = xsp;
36059 if (jj_scan_token(345)) {
36060 jj_scanpos = xsp;
36061 if (jj_scan_token(53)) {
36062 jj_scanpos = xsp;
36063 if (jj_scan_token(389)) {
36064 jj_scanpos = xsp;
36065 if (jj_scan_token(54)) {
36066 jj_scanpos = xsp;
36067 if (jj_scan_token(346)) {
36068 jj_scanpos = xsp;
36069 if (jj_scan_token(408)) {
36070 jj_scanpos = xsp;
36071 if (jj_scan_token(55)) {
36072 jj_scanpos = xsp;
36073 if (jj_scan_token(322)) {
36074 jj_scanpos = xsp;
36075 if (jj_scan_token(312)) {
36076 jj_scanpos = xsp;
36077 if (jj_scan_token(313)) {
36078 jj_scanpos = xsp;
36079 if (jj_scan_token(395)) {
36080 jj_scanpos = xsp;
36081 if (jj_scan_token(62)) {
36082 jj_scanpos = xsp;
36083 if (jj_scan_token(64)) {
36084 jj_scanpos = xsp;
36085 if (jj_scan_token(349)) {
36086 jj_scanpos = xsp;
36087 if (jj_scan_token(65)) {
36088 jj_scanpos = xsp;
36089 if (jj_scan_token(390)) {
36090 jj_scanpos = xsp;
36091 if (jj_scan_token(401)) {
36092 jj_scanpos = xsp;
36093 if (jj_scan_token(320)) {
36094 jj_scanpos = xsp;
36095 if (jj_scan_token(376)) {
36096 jj_scanpos = xsp;
36097 if (jj_scan_token(375)) {
36098 jj_scanpos = xsp;
36099 if (jj_scan_token(314)) {
36100 jj_scanpos = xsp;
36101 if (jj_scan_token(70)) {
36102 jj_scanpos = xsp;
36103 if (jj_scan_token(72)) {
36104 jj_scanpos = xsp;
36105 if (jj_scan_token(73)) {
36106 jj_scanpos = xsp;
36107 if (jj_scan_token(74)) {
36108 jj_scanpos = xsp;
36109 if (jj_scan_token(75)) {
36110 jj_scanpos = xsp;
36111 if (jj_scan_token(76)) {
36112 jj_scanpos = xsp;
36113 if (jj_scan_token(347)) {
36114 jj_scanpos = xsp;
36115 if (jj_scan_token(80)) {
36116 jj_scanpos = xsp;
36117 if (jj_scan_token(370)) {
36118 jj_scanpos = xsp;
36119 if (jj_scan_token(81)) {
36120 jj_scanpos = xsp;
36121 if (jj_scan_token(82)) {
36122 jj_scanpos = xsp;
36123 if (jj_scan_token(379)) {
36124 jj_scanpos = xsp;
36125 if (jj_scan_token(84)) {
36126 jj_scanpos = xsp;
36127 if (jj_scan_token(37)) {
36128 jj_scanpos = xsp;
36129 if (jj_scan_token(86)) {
36130 jj_scanpos = xsp;
36131 if (jj_scan_token(87)) {
36132 jj_scanpos = xsp;
36133 if (jj_scan_token(348)) {
36134 jj_scanpos = xsp;
36135 if (jj_scan_token(89)) {
36136 jj_scanpos = xsp;
36137 if (jj_scan_token(406)) {
36138 jj_scanpos = xsp;
36139 if (jj_scan_token(350)) {
36140 jj_scanpos = xsp;
36141 if (jj_scan_token(301)) {
36142 jj_scanpos = xsp;
36143 if (jj_scan_token(380)) {
36144 jj_scanpos = xsp;
36145 if (jj_scan_token(36)) {
36146 jj_scanpos = xsp;
36147 if (jj_scan_token(411)) {
36148 jj_scanpos = xsp;
36149 if (jj_scan_token(96)) {
36150 jj_scanpos = xsp;
36151 if (jj_scan_token(351)) {
36152 jj_scanpos = xsp;
36153 if (jj_scan_token(381)) {
36154 jj_scanpos = xsp;
36155 if (jj_scan_token(300)) {
36156 jj_scanpos = xsp;
36157 if (jj_scan_token(352)) {
36158 jj_scanpos = xsp;
36159 if (jj_scan_token(101)) {
36160 jj_scanpos = xsp;
36161 if (jj_scan_token(396)) {
36162 jj_scanpos = xsp;
36163 if (jj_scan_token(104)) {
36164 jj_scanpos = xsp;
36165 if (jj_scan_token(106)) {
36166 jj_scanpos = xsp;
36167 if (jj_scan_token(107)) {
36168 jj_scanpos = xsp;
36169 if (jj_scan_token(109)) {
36170 jj_scanpos = xsp;
36171 if (jj_scan_token(113)) {
36172 jj_scanpos = xsp;
36173 if (jj_scan_token(115)) {
36174 jj_scanpos = xsp;
36175 if (jj_scan_token(114)) {
36176 jj_scanpos = xsp;
36177 if (jj_scan_token(116)) {
36178 jj_scanpos = xsp;
36179 if (jj_scan_token(119)) {
36180 jj_scanpos = xsp;
36181 if (jj_scan_token(353)) {
36182 jj_scanpos = xsp;
36183 if (jj_scan_token(123)) {
36184 jj_scanpos = xsp;
36185 if (jj_scan_token(125)) {
36186 jj_scanpos = xsp;
36187 if (jj_scan_token(126)) {
36188 jj_scanpos = xsp;
36189 if (jj_scan_token(130)) {
36190 jj_scanpos = xsp;
36191 if (jj_scan_token(132)) {
36192 jj_scanpos = xsp;
36193 if (jj_scan_token(382)) {
36194 jj_scanpos = xsp;
36195 if (jj_scan_token(133)) {
36196 jj_scanpos = xsp;
36197 if (jj_scan_token(136)) {
36198 jj_scanpos = xsp;
36199 if (jj_scan_token(142)) {
36200 jj_scanpos = xsp;
36201 if (jj_scan_token(143)) {
36202 jj_scanpos = xsp;
36203 if (jj_scan_token(140)) {
36204 jj_scanpos = xsp;
36205 if (jj_scan_token(145)) {
36206 jj_scanpos = xsp;
36207 if (jj_scan_token(149)) {
36208 jj_scanpos = xsp;
36209 if (jj_scan_token(151)) {
36210 jj_scanpos = xsp;
36211 if (jj_scan_token(153)) {
36212 jj_scanpos = xsp;
36213 if (jj_scan_token(154)) {
36214 jj_scanpos = xsp;
36215 if (jj_scan_token(42)) {
36216 jj_scanpos = xsp;
36217 if (jj_scan_token(399)) {
36218 jj_scanpos = xsp;
36219 if (jj_scan_token(393)) {
36220 jj_scanpos = xsp;
36221 if (jj_scan_token(372)) {
36222 jj_scanpos = xsp;
36223 if (jj_scan_token(155)) {
36224 jj_scanpos = xsp;
36225 if (jj_scan_token(367)) {
36226 jj_scanpos = xsp;
36227 if (jj_scan_token(157)) {
36228 jj_scanpos = xsp;
36229 if (jj_scan_token(409)) {
36230 jj_scanpos = xsp;
36231 if (jj_scan_token(317)) {
36232 jj_scanpos = xsp;
36233 if (jj_scan_token(354)) {
36234 jj_scanpos = xsp;
36235 if (jj_scan_token(355)) {
36236 jj_scanpos = xsp;
36237 if (jj_scan_token(162)) {
36238 jj_scanpos = xsp;
36239 if (jj_scan_token(163)) {
36240 jj_scanpos = xsp;
36241 if (jj_scan_token(374)) {
36242 jj_scanpos = xsp;
36243 if (jj_scan_token(164)) {
36244 jj_scanpos = xsp;
36245 if (jj_scan_token(165)) {
36246 jj_scanpos = xsp;
36247 if (jj_scan_token(166)) {
36248 jj_scanpos = xsp;
36249 if (jj_scan_token(168)) {
36250 jj_scanpos = xsp;
36251 if (jj_scan_token(169)) {
36252 jj_scanpos = xsp;
36253 if (jj_scan_token(170)) {
36254 jj_scanpos = xsp;
36255 if (jj_scan_token(173)) {
36256 jj_scanpos = xsp;
36257 if (jj_scan_token(397)) {
36258 jj_scanpos = xsp;
36259 if (jj_scan_token(368)) {
36260 jj_scanpos = xsp;
36261 if (jj_scan_token(174)) {
36262 jj_scanpos = xsp;
36263 if (jj_scan_token(306)) {
36264 jj_scanpos = xsp;
36265 if (jj_scan_token(402)) {
36266 jj_scanpos = xsp;
36267 if (jj_scan_token(315)) {
36268 jj_scanpos = xsp;
36269 if (jj_scan_token(356)) {
36270 jj_scanpos = xsp;
36271 if (jj_scan_token(176)) {
36272 jj_scanpos = xsp;
36273 if (jj_scan_token(179)) {
36274 jj_scanpos = xsp;
36275 if (jj_scan_token(357)) {
36276 jj_scanpos = xsp;
36277 if (jj_scan_token(304)) {
36278 jj_scanpos = xsp;
36279 if (jj_scan_token(307)) {
36280 jj_scanpos = xsp;
36281 if (jj_scan_token(193)) {
36282 jj_scanpos = xsp;
36283 if (jj_scan_token(196)) {
36284 jj_scanpos = xsp;
36285 if (jj_scan_token(326)) {
36286 jj_scanpos = xsp;
36287 if (jj_scan_token(199)) {
36288 jj_scanpos = xsp;
36289 if (jj_scan_token(200)) {
36290 jj_scanpos = xsp;
36291 if (jj_scan_token(205)) {
36292 jj_scanpos = xsp;
36293 if (jj_scan_token(206)) {
36294 jj_scanpos = xsp;
36295 if (jj_scan_token(208)) {
36296 jj_scanpos = xsp;
36297 if (jj_scan_token(209)) {
36298 jj_scanpos = xsp;
36299 if (jj_scan_token(371)) {
36300 jj_scanpos = xsp;
36301 if (jj_scan_token(327)) {
36302 jj_scanpos = xsp;
36303 if (jj_scan_token(211)) {
36304 jj_scanpos = xsp;
36305 if (jj_scan_token(302)) {
36306 jj_scanpos = xsp;
36307 if (jj_scan_token(219)) {
36308 jj_scanpos = xsp;
36309 if (jj_scan_token(383)) {
36310 jj_scanpos = xsp;
36311 if (jj_scan_token(223)) {
36312 jj_scanpos = xsp;
36313 if (jj_scan_token(384)) {
36314 jj_scanpos = xsp;
36315 if (jj_scan_token(226)) {
36316 jj_scanpos = xsp;
36317 if (jj_scan_token(228)) {
36318 jj_scanpos = xsp;
36319 if (jj_scan_token(229)) {
36320 jj_scanpos = xsp;
36321 if (jj_scan_token(230)) {
36322 jj_scanpos = xsp;
36323 if (jj_scan_token(232)) {
36324 jj_scanpos = xsp;
36325 if (jj_scan_token(385)) {
36326 jj_scanpos = xsp;
36327 if (jj_scan_token(235)) {
36328 jj_scanpos = xsp;
36329 if (jj_scan_token(237)) {
36330 jj_scanpos = xsp;
36331 if (jj_scan_token(238)) {
36332 jj_scanpos = xsp;
36333 if (jj_scan_token(239)) {
36334 jj_scanpos = xsp;
36335 if (jj_scan_token(394)) {
36336 jj_scanpos = xsp;
36337 if (jj_scan_token(241)) {
36338 jj_scanpos = xsp;
36339 if (jj_scan_token(242)) {
36340 jj_scanpos = xsp;
36341 if (jj_scan_token(244)) {
36342 jj_scanpos = xsp;
36343 if (jj_scan_token(245)) {
36344 jj_scanpos = xsp;
36345 if (jj_scan_token(243)) {
36346 jj_scanpos = xsp;
36347 if (jj_scan_token(247)) {
36348 jj_scanpos = xsp;
36349 if (jj_scan_token(248)) {
36350 jj_scanpos = xsp;
36351 if (jj_scan_token(358)) {
36352 jj_scanpos = xsp;
36353 if (jj_scan_token(249)) {
36354 jj_scanpos = xsp;
36355 if (jj_scan_token(251)) {
36356 jj_scanpos = xsp;
36357 if (jj_scan_token(359)) {
36358 jj_scanpos = xsp;
36359 if (jj_scan_token(407)) {
36360 jj_scanpos = xsp;
36361 if (jj_scan_token(253)) {
36362 jj_scanpos = xsp;
36363 if (jj_scan_token(410)) {
36364 jj_scanpos = xsp;
36365 if (jj_scan_token(360)) {
36366 jj_scanpos = xsp;
36367 if (jj_scan_token(257)) {
36368 jj_scanpos = xsp;
36369 if (jj_scan_token(361)) {
36370 jj_scanpos = xsp;
36371 if (jj_scan_token(362)) {
36372 jj_scanpos = xsp;
36373 if (jj_scan_token(262)) {
36374 jj_scanpos = xsp;
36375 if (jj_scan_token(363)) {
36376 jj_scanpos = xsp;
36377 if (jj_scan_token(369)) {
36378 jj_scanpos = xsp;
36379 if (jj_scan_token(398)) {
36380 jj_scanpos = xsp;
36381 if (jj_scan_token(265)) {
36382 jj_scanpos = xsp;
36383 if (jj_scan_token(264)) {
36384 jj_scanpos = xsp;
36385 if (jj_scan_token(266)) {
36386 jj_scanpos = xsp;
36387 if (jj_scan_token(364)) {
36388 jj_scanpos = xsp;
36389 if (jj_scan_token(373)) {
36390 jj_scanpos = xsp;
36391 if (jj_scan_token(272)) {
36392 jj_scanpos = xsp;
36393 if (jj_scan_token(274)) {
36394 jj_scanpos = xsp;
36395 if (jj_scan_token(275)) {
36396 jj_scanpos = xsp;
36397 if (jj_scan_token(277)) {
36398 jj_scanpos = xsp;
36399 if (jj_scan_token(279)) {
36400 jj_scanpos = xsp;
36401 if (jj_scan_token(278)) {
36402 jj_scanpos = xsp;
36403 if (jj_scan_token(276)) {
36404 jj_scanpos = xsp;
36405 if (jj_scan_token(400)) {
36406 jj_scanpos = xsp;
36407 if (jj_scan_token(281)) {
36408 jj_scanpos = xsp;
36409 if (jj_scan_token(391)) {
36410 jj_scanpos = xsp;
36411 if (jj_scan_token(392)) {
36412 jj_scanpos = xsp;
36413 if (jj_scan_token(365)) {
36414 jj_scanpos = xsp;
36415 if (jj_scan_token(386)) {
36416 jj_scanpos = xsp;
36417 if (jj_scan_token(286)) {
36418 jj_scanpos = xsp;
36419 if (jj_scan_token(309)) {
36420 jj_scanpos = xsp;
36421 if (jj_scan_token(412)) {
36422 jj_scanpos = xsp;
36423 if (jj_scan_token(288)) {
36424 jj_scanpos = xsp;
36425 if (jj_scan_token(310)) {
36426 jj_scanpos = xsp;
36427 if (jj_scan_token(387)) {
36428 jj_scanpos = xsp;
36429 if (jj_scan_token(311)) {
36430 jj_scanpos = xsp;
36431 if (jj_scan_token(388)) {
36432 jj_scanpos = xsp;
36433 if (jj_scan_token(316)) {
36434 jj_scanpos = xsp;
36435 if (jj_scan_token(293)) {
36436 jj_scanpos = xsp;
36437 if (jj_scan_token(319)) {
36438 jj_scanpos = xsp;
36439 if (jj_scan_token(294)) {
36440 jj_scanpos = xsp;
36441 if (jj_scan_token(366)) {
36442 jj_scanpos = xsp;
36443 if (jj_scan_token(270)) {
36444 jj_scanpos = xsp;
36445 if (jj_scan_token(100)) {
36446 jj_scanpos = xsp;
36447 if (jj_scan_token(182)) {
36448 jj_scanpos = xsp;
36449 if (jj_scan_token(378)) {
36450 jj_scanpos = xsp;
36451 if (jj_scan_token(186)) {
36452 jj_scanpos = xsp;
36453 if (jj_scan_token(233)) {
36454 jj_scanpos = xsp;
36455 if (jj_scan_token(231)) {
36456 jj_scanpos = xsp;
36457 if (jj_scan_token(43)) return true;
36458 }
36459 }
36460 }
36461 }
36462 }
36463 }
36464 }
36465 }
36466 }
36467 }
36468 }
36469 }
36470 }
36471 }
36472 }
36473 }
36474 }
36475 }
36476 }
36477 }
36478 }
36479 }
36480 }
36481 }
36482 }
36483 }
36484 }
36485 }
36486 }
36487 }
36488 }
36489 }
36490 }
36491 }
36492 }
36493 }
36494 }
36495 }
36496 }
36497 }
36498 }
36499 }
36500 }
36501 }
36502 }
36503 }
36504 }
36505 }
36506 }
36507 }
36508 }
36509 }
36510 }
36511 }
36512 }
36513 }
36514 }
36515 }
36516 }
36517 }
36518 }
36519 }
36520 }
36521 }
36522 }
36523 }
36524 }
36525 }
36526 }
36527 }
36528 }
36529 }
36530 }
36531 }
36532 }
36533 }
36534 }
36535 }
36536 }
36537 }
36538 }
36539 }
36540 }
36541 }
36542 }
36543 }
36544 }
36545 }
36546 }
36547 }
36548 }
36549 }
36550 }
36551 }
36552 }
36553 }
36554 }
36555 }
36556 }
36557 }
36558 }
36559 }
36560 }
36561 }
36562 }
36563 }
36564 }
36565 }
36566 }
36567 }
36568 }
36569 }
36570 }
36571 }
36572 }
36573 }
36574 }
36575 }
36576 }
36577 }
36578 }
36579 }
36580 }
36581 }
36582 }
36583 }
36584 }
36585 }
36586 }
36587 }
36588 }
36589 }
36590 }
36591 }
36592 }
36593 }
36594 }
36595 }
36596 }
36597 }
36598 }
36599 }
36600 }
36601 }
36602 }
36603 }
36604 }
36605 }
36606 }
36607 }
36608 }
36609 }
36610 }
36611 }
36612 }
36613 }
36614 }
36615 }
36616 }
36617 }
36618 }
36619 }
36620 }
36621 }
36622 }
36623 }
36624 }
36625 }
36626 }
36627 }
36628 }
36629 }
36630 }
36631 }
36632 }
36633 }
36634 }
36635 }
36636 }
36637 }
36638 }
36639 }
36640 }
36641 }
36642 }
36643 }
36644 }
36645 }
36646 }
36647 }
36648 }
36649 }
36650 }
36651 }
36652 }
36653 }
36654 }
36655 }
36656 }
36657 }
36658 }
36659 }
36660 }
36661 }
36662 }
36663 }
36664 }
36665 return false;
36666 }
36667
36668 private boolean jj_3R_206() {
36669 if (jj_scan_token(SELF)) return true;
36670 if (jj_scan_token(AS)) return true;
36671 if (jj_scan_token(RESULT)) return true;
36672 return false;
36673 }
36674
36675 private boolean jj_3R_203() {
36676 if (jj_scan_token(DOUBLE)) return true;
36677 if (jj_scan_token(PRECISION)) return true;
36678 return false;
36679 }
36680
36681 private boolean jj_3R_299() {
36682 if (jj_scan_token(5)) return true;
36683 Token xsp;
36684 xsp = jj_scanpos;
36685 if (jj_3R_342()) jj_scanpos = xsp;
36686 if (jj_scan_token(7)) return true;
36687 return false;
36688 }
36689
36690 private boolean jj_3_32() {
36691 if (jj_scan_token(INTERVAL)) return true;
36692 if (jj_scan_token(DAY)) return true;
36693 return false;
36694 }
36695
36696 private boolean jj_3_31() {
36697 if (jj_scan_token(INTERVAL)) return true;
36698 if (jj_scan_token(YEAR)) return true;
36699 return false;
36700 }
36701
36702 private boolean jj_3R_353() {
36703 if (jj_scan_token(3)) return true;
36704 if (jj_3R_120()) return true;
36705 return false;
36706 }
36707
36708 private boolean jj_3R_205() {
36709 if (jj_scan_token(REF)) return true;
36710 if (jj_scan_token(CURSOR)) return true;
36711 return false;
36712 }
36713
36714 private boolean jj_3R_128() {
36715 if (jj_3R_143()) return true;
36716 Token xsp;
36717 while (true) {
36718 xsp = jj_scanpos;
36719 if (jj_3R_353()) { jj_scanpos = xsp; break; }
36720 }
36721 return false;
36722 }
36723
36724 private boolean jj_3_30() {
36725 if (jj_scan_token(LONG)) return true;
36726 if (jj_scan_token(RAW)) return true;
36727 return false;
36728 }
36729
36730 private boolean jj_3R_141() {
36731 if (jj_scan_token(3)) return true;
36732 return false;
36733 }
36734
36735 private boolean jj_3_58() {
36736 Token xsp;
36737 xsp = jj_scanpos;
36738 if (jj_3R_141()) {
36739 jj_scanpos = xsp;
36740 if (jj_3R_142()) return true;
36741 }
36742 if (jj_3R_120()) return true;
36743 return false;
36744 }
36745
36746 private boolean jj_3R_204() {
36747 Token xsp;
36748 xsp = jj_scanpos;
36749 if (jj_scan_token(67)) {
36750 jj_scanpos = xsp;
36751 if (jj_scan_token(320)) {
36752 jj_scanpos = xsp;
36753 if (jj_3_30()) {
36754 jj_scanpos = xsp;
36755 if (jj_scan_token(160)) {
36756 jj_scanpos = xsp;
36757 if (jj_scan_token(306)) {
36758 jj_scanpos = xsp;
36759 if (jj_scan_token(307)) {
36760 jj_scanpos = xsp;
36761 if (jj_scan_token(227)) {
36762 jj_scanpos = xsp;
36763 if (jj_scan_token(244)) {
36764 jj_scanpos = xsp;
36765 if (jj_scan_token(308)) {
36766 jj_scanpos = xsp;
36767 if (jj_scan_token(309)) {
36768 jj_scanpos = xsp;
36769 if (jj_scan_token(298)) {
36770 jj_scanpos = xsp;
36771 if (jj_scan_token(299)) {
36772 jj_scanpos = xsp;
36773 if (jj_scan_token(314)) {
36774 jj_scanpos = xsp;
36775 if (jj_scan_token(315)) return true;
36776 }
36777 }
36778 }
36779 }
36780 }
36781 }
36782 }
36783 }
36784 }
36785 }
36786 }
36787 }
36788 }
36789 return false;
36790 }
36791
36792 private boolean jj_3R_295() {
36793 if (jj_3R_143()) return true;
36794 Token xsp;
36795 while (true) {
36796 xsp = jj_scanpos;
36797 if (jj_3_58()) { jj_scanpos = xsp; break; }
36798 }
36799 return false;
36800 }
36801
36802 private boolean jj_3R_191() {
36803 if (jj_scan_token(21)) return true;
36804 if (jj_3R_143()) return true;
36805 if (jj_scan_token(22)) return true;
36806 return false;
36807 }
36808
36809 private boolean jj_3R_126() {
36810 Token xsp;
36811 xsp = jj_scanpos;
36812 if (jj_scan_token(188)) {
36813 jj_scanpos = xsp;
36814 if (jj_scan_token(189)) {
36815 jj_scanpos = xsp;
36816 if (jj_scan_token(68)) {
36817 jj_scanpos = xsp;
36818 if (jj_scan_token(190)) {
36819 jj_scanpos = xsp;
36820 if (jj_scan_token(191)) {
36821 jj_scanpos = xsp;
36822 if (jj_scan_token(192)) {
36823 jj_scanpos = xsp;
36824 if (jj_scan_token(59)) {
36825 jj_scanpos = xsp;
36826 if (jj_scan_token(301)) {
36827 jj_scanpos = xsp;
36828 if (jj_scan_token(91)) {
36829 jj_scanpos = xsp;
36830 if (jj_3R_203()) {
36831 jj_scanpos = xsp;
36832 if (jj_scan_token(120)) {
36833 jj_scanpos = xsp;
36834 if (jj_scan_token(303)) {
36835 jj_scanpos = xsp;
36836 if (jj_scan_token(146)) {
36837 jj_scanpos = xsp;
36838 if (jj_scan_token(174)) {
36839 jj_scanpos = xsp;
36840 if (jj_scan_token(175)) {
36841 jj_scanpos = xsp;
36842 if (jj_scan_token(187)) {
36843 jj_scanpos = xsp;
36844 if (jj_scan_token(304)) {
36845 jj_scanpos = xsp;
36846 if (jj_scan_token(215)) {
36847 jj_scanpos = xsp;
36848 if (jj_scan_token(216)) {
36849 jj_scanpos = xsp;
36850 if (jj_scan_token(217)) {
36851 jj_scanpos = xsp;
36852 if (jj_scan_token(228)) {
36853 jj_scanpos = xsp;
36854 if (jj_scan_token(305)) {
36855 jj_scanpos = xsp;
36856 if (jj_scan_token(256)) {
36857 jj_scanpos = xsp;
36858 if (jj_3R_204()) {
36859 jj_scanpos = xsp;
36860 if (jj_scan_token(61)) {
36861 jj_scanpos = xsp;
36862 if (jj_scan_token(312)) {
36863 jj_scanpos = xsp;
36864 if (jj_scan_token(313)) {
36865 jj_scanpos = xsp;
36866 if (jj_scan_token(270)) {
36867 jj_scanpos = xsp;
36868 if (jj_3R_205()) {
36869 jj_scanpos = xsp;
36870 if (jj_scan_token(88)) {
36871 jj_scanpos = xsp;
36872 if (jj_3_31()) {
36873 jj_scanpos = xsp;
36874 if (jj_3_32()) {
36875 jj_scanpos = xsp;
36876 if (jj_scan_token(274)) {
36877 jj_scanpos = xsp;
36878 if (jj_scan_token(275)) {
36879 jj_scanpos = xsp;
36880 if (jj_3R_206()) return true;
36881 }
36882 }
36883 }
36884 }
36885 }
36886 }
36887 }
36888 }
36889 }
36890 }
36891 }
36892 }
36893 }
36894 }
36895 }
36896 }
36897 }
36898 }
36899 }
36900 }
36901 }
36902 }
36903 }
36904 }
36905 }
36906 }
36907 }
36908 }
36909 }
36910 }
36911 }
36912 }
36913 }
36914 }
36915 xsp = jj_scanpos;
36916 if (jj_3_33()) jj_scanpos = xsp;
36917 xsp = jj_scanpos;
36918 if (jj_3R_207()) jj_scanpos = xsp;
36919 return false;
36920 }
36921
36922 private boolean jj_3R_240() {
36923 if (jj_scan_token(VARYING)) return true;
36924 if (jj_scan_token(ARRAY)) return true;
36925 return false;
36926 }
36927
36928 private boolean jj_3R_127() {
36929 if (jj_scan_token(UNSIGNED_NUMERIC_LITERAL)) return true;
36930 return false;
36931 }
36932
36933 private boolean jj_3_29() {
36934 if (jj_scan_token(5)) return true;
36935 if (jj_3R_127()) return true;
36936 return false;
36937 }
36938
36939 private boolean jj_3R_146() {
36940 Token xsp;
36941 xsp = jj_scanpos;
36942 if (jj_scan_token(271)) {
36943 jj_scanpos = xsp;
36944 if (jj_scan_token(310)) {
36945 jj_scanpos = xsp;
36946 if (jj_3R_240()) return true;
36947 }
36948 }
36949 xsp = jj_scanpos;
36950 if (jj_3_29()) jj_scanpos = xsp;
36951 return false;
36952 }
36953
36954 private boolean jj_3R_400() {
36955 if (jj_scan_token(CC_ELSE)) return true;
36956 if (jj_3R_236()) return true;
36957 return false;
36958 }
36959
36960 private boolean jj_3R_227() {
36961 if (jj_scan_token(A)) return true;
36962 if (jj_scan_token(SET)) return true;
36963 return false;
36964 }
36965
36966 private boolean jj_3R_137() {
36967 Token xsp;
36968 xsp = jj_scanpos;
36969 if (jj_3R_227()) {
36970 jj_scanpos = xsp;
36971 if (jj_scan_token(396)) return true;
36972 }
36973 return false;
36974 }
36975
36976 private boolean jj_3R_399() {
36977 if (jj_scan_token(CC_ELSIF)) return true;
36978 if (jj_3R_344()) return true;
36979 if (jj_scan_token(CC_THEN)) return true;
36980 if (jj_3R_236()) return true;
36981 return false;
36982 }
36983
36984 private boolean jj_3R_392() {
36985 if (jj_scan_token(NULL)) return true;
36986 return false;
36987 }
36988
36989 private boolean jj_3R_346() {
36990 if (jj_scan_token(CC_IF)) return true;
36991 if (jj_3R_344()) return true;
36992 if (jj_scan_token(CC_THEN)) return true;
36993 if (jj_3R_236()) return true;
36994 Token xsp;
36995 while (true) {
36996 xsp = jj_scanpos;
36997 if (jj_3R_399()) { jj_scanpos = xsp; break; }
36998 }
36999 while (true) {
37000 xsp = jj_scanpos;
37001 if (jj_3R_400()) { jj_scanpos = xsp; break; }
37002 }
37003 if (jj_scan_token(CC_END)) return true;
37004 return false;
37005 }
37006
37007 private boolean jj_3R_348() {
37008 if (jj_scan_token(11)) return true;
37009 Token xsp;
37010 xsp = jj_scanpos;
37011 if (jj_scan_token(284)) {
37012 jj_scanpos = xsp;
37013 if (jj_scan_token(246)) return true;
37014 }
37015 return false;
37016 }
37017
37018 private boolean jj_3R_347() {
37019 if (jj_scan_token(2)) return true;
37020 if (jj_3R_128()) return true;
37021 return false;
37022 }
37023
37024 private boolean jj_3_27() {
37025 if (jj_scan_token(REF)) return true;
37026 return false;
37027 }
37028
37029 private boolean jj_3R_305() {
37030 Token xsp;
37031 xsp = jj_scanpos;
37032 if (jj_3_27()) jj_scanpos = xsp;
37033 if (jj_3R_128()) return true;
37034 xsp = jj_scanpos;
37035 if (jj_3R_347()) jj_scanpos = xsp;
37036 xsp = jj_scanpos;
37037 if (jj_3R_348()) jj_scanpos = xsp;
37038 return false;
37039 }
37040
37041 private boolean jj_3_28() {
37042 if (jj_3R_126()) return true;
37043 return false;
37044 }
37045
37046 private boolean jj_3R_391() {
37047 Token xsp;
37048 xsp = jj_scanpos;
37049 if (jj_scan_token(283)) {
37050 jj_scanpos = xsp;
37051 if (jj_scan_token(117)) return true;
37052 }
37053 return false;
37054 }
37055
37056 private boolean jj_3R_304() {
37057 if (jj_3R_346()) return true;
37058 return false;
37059 }
37060
37061 private boolean jj_3R_236() {
37062 Token xsp;
37063 xsp = jj_scanpos;
37064 if (jj_3R_304()) {
37065 jj_scanpos = xsp;
37066 if (jj_3_28()) {
37067 jj_scanpos = xsp;
37068 if (jj_3R_305()) return true;
37069 }
37070 }
37071 return false;
37072 }
37073
37074 private boolean jj_3R_335() {
37075 if (jj_scan_token(_DEFAULT)) return true;
37076 return false;
37077 }
37078
37079 private boolean jj_3R_336() {
37080 if (jj_3R_234()) return true;
37081 return false;
37082 }
37083
37084 private boolean jj_3R_284() {
37085 if (jj_3R_124()) return true;
37086 return false;
37087 }
37088
37089 private boolean jj_3R_334() {
37090 if (jj_scan_token(9)) return true;
37091 if (jj_scan_token(10)) return true;
37092 return false;
37093 }
37094
37095 private boolean jj_3R_183() {
37096 if (jj_scan_token(STRING_LITERAL)) return true;
37097 return false;
37098 }
37099
37100 private boolean jj_3R_286() {
37101 Token xsp;
37102 xsp = jj_scanpos;
37103 if (jj_3R_334()) {
37104 jj_scanpos = xsp;
37105 if (jj_3R_335()) return true;
37106 }
37107 if (jj_3R_336()) return true;
37108 return false;
37109 }
37110
37111 private boolean jj_3R_333() {
37112 if (jj_scan_token(NOT)) return true;
37113 return false;
37114 }
37115
37116 private boolean jj_3R_285() {
37117 Token xsp;
37118 xsp = jj_scanpos;
37119 if (jj_3R_333()) jj_scanpos = xsp;
37120 if (jj_scan_token(NULL)) return true;
37121 return false;
37122 }
37123
37124 private boolean jj_3_26() {
37125 if (jj_scan_token(CONSTANT)) return true;
37126 return false;
37127 }
37128
37129 private boolean jj_3R_198() {
37130 if (jj_3R_284()) return true;
37131 Token xsp;
37132 xsp = jj_scanpos;
37133 if (jj_3_26()) jj_scanpos = xsp;
37134 if (jj_3R_236()) return true;
37135 xsp = jj_scanpos;
37136 if (jj_3R_285()) jj_scanpos = xsp;
37137 xsp = jj_scanpos;
37138 if (jj_3R_286()) jj_scanpos = xsp;
37139 return false;
37140 }
37141
37142 private boolean jj_3R_515() {
37143 if (jj_scan_token(6)) return true;
37144 if (jj_3R_475()) return true;
37145 return false;
37146 }
37147
37148 private boolean jj_3R_428() {
37149 if (jj_3R_475()) return true;
37150 Token xsp;
37151 while (true) {
37152 xsp = jj_scanpos;
37153 if (jj_3R_515()) { jj_scanpos = xsp; break; }
37154 }
37155 return false;
37156 }
37157
37158 private boolean jj_3R_197() {
37159 if (jj_3R_283()) return true;
37160 return false;
37161 }
37162
37163 private boolean jj_3R_341() {
37164 if (jj_3R_393()) return true;
37165 return false;
37166 }
37167
37168 private boolean jj_3R_340() {
37169 if (jj_3R_392()) return true;
37170 return false;
37171 }
37172
37173 private boolean jj_3R_386() {
37174 if (jj_scan_token(5)) return true;
37175 Token xsp;
37176 xsp = jj_scanpos;
37177 if (jj_3R_428()) jj_scanpos = xsp;
37178 if (jj_scan_token(7)) return true;
37179 return false;
37180 }
37181
37182 private boolean jj_3R_339() {
37183 if (jj_3R_391()) return true;
37184 return false;
37185 }
37186
37187 private boolean jj_3R_338() {
37188 if (jj_3R_183()) return true;
37189 return false;
37190 }
37191
37192 private boolean jj_3R_120() {
37193 Token xsp;
37194 xsp = jj_scanpos;
37195 if (jj_scan_token(420)) {
37196 jj_scanpos = xsp;
37197 if (jj_scan_token(428)) {
37198 jj_scanpos = xsp;
37199 if (jj_3R_197()) {
37200 jj_scanpos = xsp;
37201 if (jj_scan_token(35)) {
37202 jj_scanpos = xsp;
37203 if (jj_scan_token(38)) {
37204 jj_scanpos = xsp;
37205 if (jj_scan_token(39)) {
37206 jj_scanpos = xsp;
37207 if (jj_scan_token(40)) {
37208 jj_scanpos = xsp;
37209 if (jj_scan_token(41)) {
37210 jj_scanpos = xsp;
37211 if (jj_scan_token(50)) {
37212 jj_scanpos = xsp;
37213 if (jj_scan_token(56)) {
37214 jj_scanpos = xsp;
37215 if (jj_scan_token(59)) {
37216 jj_scanpos = xsp;
37217 if (jj_scan_token(60)) {
37218 jj_scanpos = xsp;
37219 if (jj_scan_token(61)) {
37220 jj_scanpos = xsp;
37221 if (jj_scan_token(67)) {
37222 jj_scanpos = xsp;
37223 if (jj_scan_token(68)) {
37224 jj_scanpos = xsp;
37225 if (jj_scan_token(79)) {
37226 jj_scanpos = xsp;
37227 if (jj_scan_token(85)) {
37228 jj_scanpos = xsp;
37229 if (jj_scan_token(88)) {
37230 jj_scanpos = xsp;
37231 if (jj_scan_token(91)) {
37232 jj_scanpos = xsp;
37233 if (jj_scan_token(93)) {
37234 jj_scanpos = xsp;
37235 if (jj_scan_token(98)) {
37236 jj_scanpos = xsp;
37237 if (jj_scan_token(103)) {
37238 jj_scanpos = xsp;
37239 if (jj_scan_token(111)) {
37240 jj_scanpos = xsp;
37241 if (jj_scan_token(112)) {
37242 jj_scanpos = xsp;
37243 if (jj_scan_token(120)) {
37244 jj_scanpos = xsp;
37245 if (jj_scan_token(122)) {
37246 jj_scanpos = xsp;
37247 if (jj_scan_token(146)) {
37248 jj_scanpos = xsp;
37249 if (jj_scan_token(147)) {
37250 jj_scanpos = xsp;
37251 if (jj_scan_token(160)) {
37252 jj_scanpos = xsp;
37253 if (jj_scan_token(161)) {
37254 jj_scanpos = xsp;
37255 if (jj_scan_token(171)) {
37256 jj_scanpos = xsp;
37257 if (jj_scan_token(175)) {
37258 jj_scanpos = xsp;
37259 if (jj_scan_token(178)) {
37260 jj_scanpos = xsp;
37261 if (jj_scan_token(181)) {
37262 jj_scanpos = xsp;
37263 if (jj_scan_token(187)) {
37264 jj_scanpos = xsp;
37265 if (jj_scan_token(188)) {
37266 jj_scanpos = xsp;
37267 if (jj_scan_token(189)) {
37268 jj_scanpos = xsp;
37269 if (jj_scan_token(190)) {
37270 jj_scanpos = xsp;
37271 if (jj_scan_token(191)) {
37272 jj_scanpos = xsp;
37273 if (jj_scan_token(192)) {
37274 jj_scanpos = xsp;
37275 if (jj_scan_token(194)) {
37276 jj_scanpos = xsp;
37277 if (jj_scan_token(201)) {
37278 jj_scanpos = xsp;
37279 if (jj_scan_token(207)) {
37280 jj_scanpos = xsp;
37281 if (jj_scan_token(215)) {
37282 jj_scanpos = xsp;
37283 if (jj_scan_token(216)) {
37284 jj_scanpos = xsp;
37285 if (jj_scan_token(217)) {
37286 jj_scanpos = xsp;
37287 if (jj_scan_token(218)) {
37288 jj_scanpos = xsp;
37289 if (jj_scan_token(220)) {
37290 jj_scanpos = xsp;
37291 if (jj_scan_token(222)) {
37292 jj_scanpos = xsp;
37293 if (jj_scan_token(221)) {
37294 jj_scanpos = xsp;
37295 if (jj_scan_token(225)) {
37296 jj_scanpos = xsp;
37297 if (jj_scan_token(227)) {
37298 jj_scanpos = xsp;
37299 if (jj_scan_token(246)) {
37300 jj_scanpos = xsp;
37301 if (jj_scan_token(252)) {
37302 jj_scanpos = xsp;
37303 if (jj_scan_token(256)) {
37304 jj_scanpos = xsp;
37305 if (jj_scan_token(259)) {
37306 jj_scanpos = xsp;
37307 if (jj_scan_token(260)) {
37308 jj_scanpos = xsp;
37309 if (jj_scan_token(263)) {
37310 jj_scanpos = xsp;
37311 if (jj_scan_token(267)) {
37312 jj_scanpos = xsp;
37313 if (jj_scan_token(268)) {
37314 jj_scanpos = xsp;
37315 if (jj_scan_token(269)) {
37316 jj_scanpos = xsp;
37317 if (jj_scan_token(282)) {
37318 jj_scanpos = xsp;
37319 if (jj_scan_token(284)) {
37320 jj_scanpos = xsp;
37321 if (jj_scan_token(285)) {
37322 jj_scanpos = xsp;
37323 if (jj_scan_token(298)) {
37324 jj_scanpos = xsp;
37325 if (jj_scan_token(299)) {
37326 jj_scanpos = xsp;
37327 if (jj_scan_token(303)) {
37328 jj_scanpos = xsp;
37329 if (jj_scan_token(305)) {
37330 jj_scanpos = xsp;
37331 if (jj_scan_token(308)) {
37332 jj_scanpos = xsp;
37333 if (jj_scan_token(292)) return true;
37334 }
37335 }
37336 }
37337 }
37338 }
37339 }
37340 }
37341 }
37342 }
37343 }
37344 }
37345 }
37346 }
37347 }
37348 }
37349 }
37350 }
37351 }
37352 }
37353 }
37354 }
37355 }
37356 }
37357 }
37358 }
37359 }
37360 }
37361 }
37362 }
37363 }
37364 }
37365 }
37366 }
37367 }
37368 }
37369 }
37370 }
37371 }
37372 }
37373 }
37374 }
37375 }
37376 }
37377 }
37378 }
37379 }
37380 }
37381 }
37382 }
37383 }
37384 }
37385 }
37386 }
37387 }
37388 }
37389 }
37390 }
37391 }
37392 }
37393 }
37394 }
37395 }
37396 }
37397 }
37398 }
37399 }
37400 }
37401 }
37402 }
37403 return false;
37404 }
37405
37406 private boolean jj_3_23() {
37407 if (jj_scan_token(NOCOPY)) return true;
37408 return false;
37409 }
37410
37411 private boolean jj_3R_326() {
37412 if (jj_3R_386()) return true;
37413 return false;
37414 }
37415
37416 private boolean jj_3R_337() {
37417 if (jj_3R_127()) return true;
37418 return false;
37419 }
37420
37421 private boolean jj_3R_294() {
37422 Token xsp;
37423 xsp = jj_scanpos;
37424 if (jj_3R_337()) {
37425 jj_scanpos = xsp;
37426 if (jj_scan_token(425)) {
37427 jj_scanpos = xsp;
37428 if (jj_3R_338()) {
37429 jj_scanpos = xsp;
37430 if (jj_3R_339()) {
37431 jj_scanpos = xsp;
37432 if (jj_3R_340()) {
37433 jj_scanpos = xsp;
37434 if (jj_3R_341()) return true;
37435 }
37436 }
37437 }
37438 }
37439 }
37440 return false;
37441 }
37442
37443 private boolean jj_3R_479() {
37444 if (jj_3R_234()) return true;
37445 return false;
37446 }
37447
37448 private boolean jj_3R_478() {
37449 if (jj_3R_183()) return true;
37450 return false;
37451 }
37452
37453 private boolean jj_3R_477() {
37454 if (jj_scan_token(SESSIONTIMEZONE)) return true;
37455 return false;
37456 }
37457
37458 private boolean jj_3R_325() {
37459 if (jj_scan_token(RETURN)) return true;
37460 if (jj_3R_236()) return true;
37461 return false;
37462 }
37463
37464 private boolean jj_3R_476() {
37465 if (jj_scan_token(DBTIMEZONE)) return true;
37466 return false;
37467 }
37468
37469 private boolean jj_3R_279() {
37470 if (jj_scan_token(PROCEDURE)) return true;
37471 if (jj_3R_155()) return true;
37472 Token xsp;
37473 xsp = jj_scanpos;
37474 if (jj_3R_326()) jj_scanpos = xsp;
37475 return false;
37476 }
37477
37478 private boolean jj_3R_464() {
37479 if (jj_3R_124()) return true;
37480 return false;
37481 }
37482
37483 private boolean jj_3R_125() {
37484 if (jj_scan_token(IN)) return true;
37485 if (jj_scan_token(OUT)) return true;
37486 return false;
37487 }
37488
37489 private boolean jj_3R_298() {
37490 if (jj_scan_token(TIME)) return true;
37491 if (jj_scan_token(ZONE)) return true;
37492 Token xsp;
37493 xsp = jj_scanpos;
37494 if (jj_3R_476()) {
37495 jj_scanpos = xsp;
37496 if (jj_3R_477()) {
37497 jj_scanpos = xsp;
37498 if (jj_3R_478()) {
37499 jj_scanpos = xsp;
37500 if (jj_3R_479()) return true;
37501 }
37502 }
37503 }
37504 return false;
37505 }
37506
37507 private boolean jj_3R_226() {
37508 if (jj_3R_299()) return true;
37509 return false;
37510 }
37511
37512 private boolean jj_3R_297() {
37513 if (jj_scan_token(LOCAL)) return true;
37514 return false;
37515 }
37516
37517 private boolean jj_3R_238() {
37518 if (jj_3R_283()) return true;
37519 return false;
37520 }
37521
37522 private boolean jj_3R_324() {
37523 if (jj_3R_386()) return true;
37524 return false;
37525 }
37526
37527 private boolean jj_3R_225() {
37528 if (jj_scan_token(AT)) return true;
37529 Token xsp;
37530 xsp = jj_scanpos;
37531 if (jj_3R_297()) {
37532 jj_scanpos = xsp;
37533 if (jj_3R_298()) return true;
37534 }
37535 return false;
37536 }
37537
37538 private boolean jj_3R_224() {
37539 if (jj_scan_token(2)) return true;
37540 if (jj_3R_120()) return true;
37541 return false;
37542 }
37543
37544 private boolean jj_3R_278() {
37545 if (jj_scan_token(FUNCTION)) return true;
37546 if (jj_3R_155()) return true;
37547 Token xsp;
37548 xsp = jj_scanpos;
37549 if (jj_3R_324()) jj_scanpos = xsp;
37550 xsp = jj_scanpos;
37551 if (jj_3R_325()) jj_scanpos = xsp;
37552 return false;
37553 }
37554
37555 private boolean jj_3R_143() {
37556 Token xsp;
37557 xsp = jj_scanpos;
37558 if (jj_scan_token(420)) {
37559 jj_scanpos = xsp;
37560 if (jj_scan_token(428)) {
37561 jj_scanpos = xsp;
37562 if (jj_3R_238()) {
37563 jj_scanpos = xsp;
37564 if (jj_scan_token(60)) {
37565 jj_scanpos = xsp;
37566 if (jj_scan_token(171)) {
37567 jj_scanpos = xsp;
37568 if (jj_scan_token(201)) {
37569 jj_scanpos = xsp;
37570 if (jj_scan_token(222)) {
37571 jj_scanpos = xsp;
37572 if (jj_scan_token(227)) {
37573 jj_scanpos = xsp;
37574 if (jj_scan_token(35)) {
37575 jj_scanpos = xsp;
37576 if (jj_scan_token(308)) {
37577 jj_scanpos = xsp;
37578 if (jj_scan_token(258)) {
37579 jj_scanpos = xsp;
37580 if (jj_scan_token(259)) {
37581 jj_scanpos = xsp;
37582 if (jj_scan_token(260)) {
37583 jj_scanpos = xsp;
37584 if (jj_scan_token(269)) {
37585 jj_scanpos = xsp;
37586 if (jj_scan_token(284)) {
37587 jj_scanpos = xsp;
37588 if (jj_scan_token(161)) {
37589 jj_scanpos = xsp;
37590 if (jj_scan_token(303)) {
37591 jj_scanpos = xsp;
37592 if (jj_scan_token(50)) return true;
37593 }
37594 }
37595 }
37596 }
37597 }
37598 }
37599 }
37600 }
37601 }
37602 }
37603 }
37604 }
37605 }
37606 }
37607 }
37608 }
37609 }
37610 return false;
37611 }
37612
37613 private boolean jj_3R_625() {
37614 if (jj_scan_token(3)) return true;
37615 if (jj_3R_124()) return true;
37616 return false;
37617 }
37618
37619 private boolean jj_3R_194() {
37620 Token xsp;
37621 xsp = jj_scanpos;
37622 if (jj_3R_278()) {
37623 jj_scanpos = xsp;
37624 if (jj_3R_279()) return true;
37625 }
37626 return false;
37627 }
37628
37629 private boolean jj_3R_636() {
37630 if (jj_scan_token(NOT)) return true;
37631 return false;
37632 }
37633
37634 private boolean jj_3R_624() {
37635 if (jj_scan_token(6)) return true;
37636 if (jj_3R_124()) return true;
37637 return false;
37638 }
37639
37640 private boolean jj_3R_223() {
37641 if (jj_scan_token(3)) return true;
37642 if (jj_3R_120()) return true;
37643 return false;
37644 }
37645
37646 private boolean jj_3_24() {
37647 Token xsp;
37648 xsp = jj_scanpos;
37649 if (jj_scan_token(207)) {
37650 jj_scanpos = xsp;
37651 if (jj_3R_125()) return true;
37652 }
37653 xsp = jj_scanpos;
37654 if (jj_3_23()) jj_scanpos = xsp;
37655 return false;
37656 }
37657
37658 private boolean jj_3R_136() {
37659 Token xsp;
37660 xsp = jj_scanpos;
37661 if (jj_3R_223()) {
37662 jj_scanpos = xsp;
37663 if (jj_3R_224()) {
37664 jj_scanpos = xsp;
37665 if (jj_3R_225()) {
37666 jj_scanpos = xsp;
37667 if (jj_3R_226()) return true;
37668 }
37669 }
37670 }
37671 return false;
37672 }
37673
37674 private boolean jj_3R_560() {
37675 if (jj_3R_236()) return true;
37676 return false;
37677 }
37678
37679 private boolean jj_3R_463() {
37680 if (jj_3R_351()) return true;
37681 return false;
37682 }
37683
37684 private boolean jj_3R_601() {
37685 if (jj_scan_token(6)) return true;
37686 if (jj_3R_124()) return true;
37687 Token xsp;
37688 xsp = jj_scanpos;
37689 if (jj_3R_625()) jj_scanpos = xsp;
37690 return false;
37691 }
37692
37693 private boolean jj_3R_487() {
37694 if (jj_scan_token(3)) return true;
37695 if (jj_3R_124()) return true;
37696 return false;
37697 }
37698
37699 private boolean jj_3R_471() {
37700 if (jj_3R_147()) return true;
37701 return false;
37702 }
37703
37704 private boolean jj_3R_631() {
37705 if (jj_scan_token(NOT)) return true;
37706 return false;
37707 }
37708
37709 private boolean jj_3R_470() {
37710 if (jj_3R_118()) return true;
37711 return false;
37712 }
37713
37714 private boolean jj_3_57() {
37715 Token xsp;
37716 if (jj_scan_token(5)) return true;
37717 while (true) {
37718 xsp = jj_scanpos;
37719 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37720 }
37721 if (jj_scan_token(WITH)) return true;
37722 return false;
37723 }
37724
37725 private boolean jj_3_56() {
37726 if (jj_scan_token(WITH)) return true;
37727 return false;
37728 }
37729
37730 private boolean jj_3R_426() {
37731 Token xsp;
37732 xsp = jj_scanpos;
37733 if (jj_3R_470()) {
37734 jj_scanpos = xsp;
37735 if (jj_3R_471()) return true;
37736 }
37737 return false;
37738 }
37739
37740 private boolean jj_3_55() {
37741 Token xsp;
37742 if (jj_scan_token(5)) return true;
37743 while (true) {
37744 xsp = jj_scanpos;
37745 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37746 }
37747 if (jj_scan_token(SELECT)) return true;
37748 return false;
37749 }
37750
37751 private boolean jj_3R_598() {
37752 if (jj_scan_token(9)) return true;
37753 if (jj_scan_token(10)) return true;
37754 return false;
37755 }
37756
37757 private boolean jj_3_54() {
37758 if (jj_scan_token(SELECT)) return true;
37759 return false;
37760 }
37761
37762 private boolean jj_3R_296() {
37763 if (jj_scan_token(6)) return true;
37764 if (jj_3R_234()) return true;
37765 return false;
37766 }
37767
37768 private boolean jj_3R_561() {
37769 Token xsp;
37770 xsp = jj_scanpos;
37771 if (jj_3R_598()) {
37772 jj_scanpos = xsp;
37773 if (jj_scan_token(92)) return true;
37774 }
37775 if (jj_3R_234()) return true;
37776 return false;
37777 }
37778
37779 private boolean jj_3_25() {
37780 Token xsp;
37781 xsp = jj_scanpos;
37782 if (jj_3_24()) {
37783 jj_scanpos = xsp;
37784 if (jj_scan_token(137)) return true;
37785 }
37786 return false;
37787 }
37788
37789 private boolean jj_3_53() {
37790 if (jj_3R_140()) return true;
37791 return false;
37792 }
37793
37794 private boolean jj_3_52() {
37795 if (jj_3R_139()) return true;
37796 return false;
37797 }
37798
37799 private boolean jj_3R_222() {
37800 if (jj_scan_token(5)) return true;
37801 if (jj_3R_234()) return true;
37802 Token xsp;
37803 while (true) {
37804 xsp = jj_scanpos;
37805 if (jj_3R_296()) { jj_scanpos = xsp; break; }
37806 }
37807 if (jj_scan_token(7)) return true;
37808 return false;
37809 }
37810
37811 private boolean jj_3_51() {
37812 if (jj_3R_138()) return true;
37813 return false;
37814 }
37815
37816 private boolean jj_3_50() {
37817 if (jj_3R_137()) return true;
37818 return false;
37819 }
37820
37821 private boolean jj_3R_600() {
37822 if (jj_scan_token(3)) return true;
37823 if (jj_3R_124()) return true;
37824 return false;
37825 }
37826
37827 private boolean jj_3R_221() {
37828 if (jj_scan_token(5)) return true;
37829 if (jj_3R_180()) return true;
37830 if (jj_scan_token(7)) return true;
37831 return false;
37832 }
37833
37834 private boolean jj_3R_517() {
37835 if (jj_3R_124()) return true;
37836 return false;
37837 }
37838
37839 private boolean jj_3R_462() {
37840 if (jj_3R_174()) return true;
37841 return false;
37842 }
37843
37844 private boolean jj_3R_220() {
37845 if (jj_scan_token(WITH)) return true;
37846 if (jj_3R_180()) return true;
37847 return false;
37848 }
37849
37850 private boolean jj_3R_461() {
37851 if (jj_3R_423()) return true;
37852 return false;
37853 }
37854
37855 private boolean jj_3R_388() {
37856 if (jj_scan_token(USING)) return true;
37857 if (jj_3R_124()) return true;
37858 Token xsp;
37859 xsp = jj_scanpos;
37860 if (jj_3R_487()) jj_scanpos = xsp;
37861 return false;
37862 }
37863
37864 private boolean jj_3R_219() {
37865 if (jj_scan_token(5)) return true;
37866 if (jj_3R_180()) return true;
37867 if (jj_scan_token(7)) return true;
37868 return false;
37869 }
37870
37871 private boolean jj_3R_218() {
37872 if (jj_scan_token(SELECT)) return true;
37873 if (jj_3R_180()) return true;
37874 return false;
37875 }
37876
37877 private boolean jj_3R_217() {
37878 if (jj_3R_295()) return true;
37879 return false;
37880 }
37881
37882 private boolean jj_3R_475() {
37883 if (jj_3R_124()) return true;
37884 Token xsp;
37885 xsp = jj_scanpos;
37886 if (jj_3_25()) jj_scanpos = xsp;
37887 xsp = jj_scanpos;
37888 if (jj_scan_token(8)) {
37889 jj_scanpos = xsp;
37890 if (jj_3R_560()) return true;
37891 }
37892 xsp = jj_scanpos;
37893 if (jj_3R_561()) jj_scanpos = xsp;
37894 return false;
37895 }
37896
37897 private boolean jj_3R_216() {
37898 if (jj_3R_140()) return true;
37899 return false;
37900 }
37901
37902 private boolean jj_3R_215() {
37903 if (jj_3R_139()) return true;
37904 return false;
37905 }
37906
37907 private boolean jj_3R_214() {
37908 if (jj_3R_138()) return true;
37909 return false;
37910 }
37911
37912 private boolean jj_3R_213() {
37913 if (jj_3R_137()) return true;
37914 return false;
37915 }
37916
37917 private boolean jj_3R_212() {
37918 if (jj_3R_294()) return true;
37919 return false;
37920 }
37921
37922 private boolean jj_3R_516() {
37923 if (jj_scan_token(3)) return true;
37924 if (jj_3R_124()) return true;
37925 return false;
37926 }
37927
37928 private boolean jj_3R_135() {
37929 Token xsp;
37930 xsp = jj_scanpos;
37931 if (jj_3R_212()) {
37932 jj_scanpos = xsp;
37933 if (jj_3R_213()) {
37934 jj_scanpos = xsp;
37935 if (jj_3R_214()) {
37936 jj_scanpos = xsp;
37937 if (jj_3R_215()) {
37938 jj_scanpos = xsp;
37939 if (jj_3R_216()) {
37940 jj_scanpos = xsp;
37941 if (jj_3R_217()) {
37942 jj_scanpos = xsp;
37943 if (jj_3R_218()) {
37944 jj_scanpos = xsp;
37945 if (jj_3R_219()) {
37946 jj_scanpos = xsp;
37947 if (jj_3R_220()) {
37948 jj_scanpos = xsp;
37949 if (jj_3R_221()) {
37950 jj_scanpos = xsp;
37951 if (jj_3R_222()) return true;
37952 }
37953 }
37954 }
37955 }
37956 }
37957 }
37958 }
37959 }
37960 }
37961 }
37962 return false;
37963 }
37964
37965 private boolean jj_3R_332() {
37966 if (jj_3R_192()) return true;
37967 if (jj_scan_token(BEGIN)) return true;
37968 Token xsp;
37969 xsp = jj_scanpos;
37970 if (jj_3R_461()) jj_scanpos = xsp;
37971 while (true) {
37972 xsp = jj_scanpos;
37973 if (jj_3R_462()) { jj_scanpos = xsp; break; }
37974 }
37975 xsp = jj_scanpos;
37976 if (jj_3R_463()) jj_scanpos = xsp;
37977 if (jj_scan_token(END)) return true;
37978 xsp = jj_scanpos;
37979 if (jj_3R_464()) jj_scanpos = xsp;
37980 return false;
37981 }
37982
37983 private boolean jj_3_49() {
37984 if (jj_3R_136()) return true;
37985 return false;
37986 }
37987
37988 private boolean jj_3_48() {
37989 if (jj_scan_token(NEW)) return true;
37990 if (jj_3R_135()) return true;
37991 return false;
37992 }
37993
37994 private boolean jj_3R_293() {
37995 if (jj_3R_135()) return true;
37996 return false;
37997 }
37998
37999 private boolean jj_3_22() {
38000 if (jj_3R_124()) return true;
38001 if (jj_scan_token(3)) return true;
38002 return false;
38003 }
38004
38005 private boolean jj_3_21() {
38006 if (jj_3R_123()) return true;
38007 return false;
38008 }
38009
38010 private boolean jj_3R_155() {
38011 Token xsp;
38012 xsp = jj_scanpos;
38013 if (jj_3_22()) jj_scanpos = xsp;
38014 if (jj_3R_124()) return true;
38015 return false;
38016 }
38017
38018 private boolean jj_3R_390() {
38019 if (jj_scan_token(RELIES_ON)) return true;
38020 if (jj_scan_token(5)) return true;
38021 if (jj_3R_124()) return true;
38022 Token xsp;
38023 xsp = jj_scanpos;
38024 if (jj_3R_600()) jj_scanpos = xsp;
38025 while (true) {
38026 xsp = jj_scanpos;
38027 if (jj_3R_601()) { jj_scanpos = xsp; break; }
38028 }
38029 if (jj_scan_token(7)) return true;
38030 return false;
38031 }
38032
38033 private boolean jj_3R_387() {
38034 if (jj_3R_429()) return true;
38035 return false;
38036 }
38037
38038 private boolean jj_3R_292() {
38039 if (jj_scan_token(NEW)) return true;
38040 if (jj_3R_135()) return true;
38041 return false;
38042 }
38043
38044 private boolean jj_3R_431() {
38045 Token xsp;
38046 xsp = jj_scanpos;
38047 if (jj_scan_token(204)) {
38048 jj_scanpos = xsp;
38049 if (jj_scan_token(71)) return true;
38050 }
38051 xsp = jj_scanpos;
38052 if (jj_3R_517()) jj_scanpos = xsp;
38053 if (jj_scan_token(BY)) return true;
38054 if (jj_scan_token(5)) return true;
38055 if (jj_3R_124()) return true;
38056 while (true) {
38057 xsp = jj_scanpos;
38058 if (jj_3R_624()) { jj_scanpos = xsp; break; }
38059 }
38060 if (jj_scan_token(7)) return true;
38061 return false;
38062 }
38063
38064 private boolean jj_3R_637() {
38065 if (jj_scan_token(6)) return true;
38066 Token xsp;
38067 xsp = jj_scanpos;
38068 if (jj_scan_token(198)) jj_scanpos = xsp;
38069 if (jj_3R_295()) return true;
38070 return false;
38071 }
38072
38073 private boolean jj_3R_282() {
38074 Token xsp;
38075 xsp = jj_scanpos;
38076 if (jj_scan_token(152)) {
38077 jj_scanpos = xsp;
38078 if (jj_scan_token(51)) return true;
38079 }
38080 xsp = jj_scanpos;
38081 if (jj_3_21()) {
38082 jj_scanpos = xsp;
38083 if (jj_3R_332()) return true;
38084 }
38085 return false;
38086 }
38087
38088 private boolean jj_3R_211() {
38089 Token xsp;
38090 xsp = jj_scanpos;
38091 if (jj_3R_292()) {
38092 jj_scanpos = xsp;
38093 if (jj_3R_293()) return true;
38094 }
38095 while (true) {
38096 xsp = jj_scanpos;
38097 if (jj_3_49()) { jj_scanpos = xsp; break; }
38098 }
38099 return false;
38100 }
38101
38102 private boolean jj_3R_430() {
38103 if (jj_scan_token(USING)) return true;
38104 if (jj_3R_124()) return true;
38105 Token xsp;
38106 xsp = jj_scanpos;
38107 if (jj_3R_516()) jj_scanpos = xsp;
38108 return false;
38109 }
38110
38111 private boolean jj_3R_389() {
38112 Token xsp;
38113 xsp = jj_scanpos;
38114 if (jj_3R_430()) {
38115 jj_scanpos = xsp;
38116 if (jj_3R_431()) return true;
38117 }
38118 return false;
38119 }
38120
38121 private boolean jj_3R_210() {
38122 if (jj_scan_token(NEW_DOT)) return true;
38123 if (jj_3R_120()) return true;
38124 return false;
38125 }
38126
38127 private boolean jj_3R_277() {
38128 Token xsp;
38129 xsp = jj_scanpos;
38130 if (jj_scan_token(100)) {
38131 jj_scanpos = xsp;
38132 if (jj_scan_token(182)) return true;
38133 }
38134 return false;
38135 }
38136
38137 private boolean jj_3R_133() {
38138 Token xsp;
38139 xsp = jj_scanpos;
38140 if (jj_3R_210()) {
38141 jj_scanpos = xsp;
38142 if (jj_3R_211()) return true;
38143 }
38144 return false;
38145 }
38146
38147 private boolean jj_3R_281() {
38148 if (jj_scan_token(AGGREGATE)) return true;
38149 if (jj_scan_token(USING)) return true;
38150 if (jj_3R_124()) return true;
38151 return false;
38152 }
38153
38154 private boolean jj_3R_331() {
38155 if (jj_scan_token(RESULT_CACHE)) return true;
38156 Token xsp;
38157 xsp = jj_scanpos;
38158 if (jj_3R_390()) jj_scanpos = xsp;
38159 return false;
38160 }
38161
38162 private boolean jj_3R_330() {
38163 if (jj_scan_token(PIPELINED)) return true;
38164 Token xsp;
38165 xsp = jj_scanpos;
38166 if (jj_3R_389()) jj_scanpos = xsp;
38167 return false;
38168 }
38169
38170 private boolean jj_3_47() {
38171 if (jj_scan_token(IDENTIFIER)) return true;
38172 if (jj_scan_token(IS)) return true;
38173 return false;
38174 }
38175
38176 private boolean jj_3R_329() {
38177 if (jj_scan_token(PARALLEL_ENABLE)) return true;
38178 Token xsp;
38179 xsp = jj_scanpos;
38180 if (jj_3R_387()) jj_scanpos = xsp;
38181 xsp = jj_scanpos;
38182 if (jj_3R_388()) jj_scanpos = xsp;
38183 return false;
38184 }
38185
38186 private boolean jj_3R_328() {
38187 if (jj_3R_239()) return true;
38188 return false;
38189 }
38190
38191 private boolean jj_3R_134() {
38192 if (jj_scan_token(NOT)) return true;
38193 if (jj_scan_token(NULL)) return true;
38194 return false;
38195 }
38196
38197 private boolean jj_3R_635() {
38198 if (jj_3R_133()) return true;
38199 return false;
38200 }
38201
38202 private boolean jj_3R_280() {
38203 Token xsp;
38204 xsp = jj_scanpos;
38205 if (jj_3R_327()) {
38206 jj_scanpos = xsp;
38207 if (jj_scan_token(95)) {
38208 jj_scanpos = xsp;
38209 if (jj_3R_328()) {
38210 jj_scanpos = xsp;
38211 if (jj_3R_329()) {
38212 jj_scanpos = xsp;
38213 if (jj_3R_330()) {
38214 jj_scanpos = xsp;
38215 if (jj_3R_331()) return true;
38216 }
38217 }
38218 }
38219 }
38220 }
38221 return false;
38222 }
38223
38224 private boolean jj_3R_327() {
38225 if (jj_scan_token(AUTHID)) return true;
38226 Token xsp;
38227 xsp = jj_scanpos;
38228 if (jj_scan_token(37)) {
38229 jj_scanpos = xsp;
38230 if (jj_scan_token(36)) return true;
38231 }
38232 return false;
38233 }
38234
38235 private boolean jj_3R_196() {
38236 Token xsp;
38237 while (true) {
38238 xsp = jj_scanpos;
38239 if (jj_3R_280()) { jj_scanpos = xsp; break; }
38240 }
38241 xsp = jj_scanpos;
38242 if (jj_3R_281()) jj_scanpos = xsp;
38243 xsp = jj_scanpos;
38244 if (jj_3R_282()) jj_scanpos = xsp;
38245 if (jj_scan_token(4)) return true;
38246 return false;
38247 }
38248
38249 private boolean jj_3R_276() {
38250 if (jj_scan_token(OR)) return true;
38251 if (jj_scan_token(REPLACE)) return true;
38252 return false;
38253 }
38254
38255 private boolean jj_3R_634() {
38256 if (jj_3R_295()) return true;
38257 if (jj_scan_token(IS)) return true;
38258 Token xsp;
38259 xsp = jj_scanpos;
38260 if (jj_3R_636()) jj_scanpos = xsp;
38261 if (jj_scan_token(OF)) return true;
38262 xsp = jj_scanpos;
38263 if (jj_scan_token(284)) jj_scanpos = xsp;
38264 if (jj_scan_token(5)) return true;
38265 xsp = jj_scanpos;
38266 if (jj_scan_token(198)) jj_scanpos = xsp;
38267 if (jj_3R_295()) return true;
38268 while (true) {
38269 xsp = jj_scanpos;
38270 if (jj_3R_637()) { jj_scanpos = xsp; break; }
38271 }
38272 if (jj_scan_token(7)) return true;
38273 return false;
38274 }
38275
38276 private boolean jj_3R_632() {
38277 Token xsp;
38278 xsp = jj_scanpos;
38279 if (jj_3R_634()) {
38280 jj_scanpos = xsp;
38281 if (jj_3R_635()) return true;
38282 }
38283 return false;
38284 }
38285
38286 private boolean jj_3R_195() {
38287 if (jj_3R_249()) return true;
38288 return false;
38289 }
38290
38291 private boolean jj_3R_193() {
38292 if (jj_scan_token(CREATE)) return true;
38293 Token xsp;
38294 xsp = jj_scanpos;
38295 if (jj_3R_276()) jj_scanpos = xsp;
38296 xsp = jj_scanpos;
38297 if (jj_3R_277()) jj_scanpos = xsp;
38298 return false;
38299 }
38300
38301 private boolean jj_3R_118() {
38302 Token xsp;
38303 xsp = jj_scanpos;
38304 if (jj_3R_193()) jj_scanpos = xsp;
38305 if (jj_3R_194()) return true;
38306 xsp = jj_scanpos;
38307 if (jj_3R_195()) {
38308 jj_scanpos = xsp;
38309 if (jj_3R_196()) return true;
38310 }
38311 return false;
38312 }
38313
38314 private boolean jj_3_46() {
38315 if (jj_scan_token(IDENTIFIER)) return true;
38316 if (jj_scan_token(IS)) return true;
38317 Token xsp;
38318 xsp = jj_scanpos;
38319 if (jj_3R_134()) {
38320 jj_scanpos = xsp;
38321 if (jj_scan_token(185)) return true;
38322 }
38323 return false;
38324 }
38325
38326 private boolean jj_3R_627() {
38327 if (jj_3R_632()) return true;
38328 return false;
38329 }
38330
38331 private boolean jj_3R_626() {
38332 if (jj_3R_295()) return true;
38333 if (jj_scan_token(IS)) return true;
38334 Token xsp;
38335 xsp = jj_scanpos;
38336 if (jj_3R_631()) jj_scanpos = xsp;
38337 if (jj_scan_token(NULL)) return true;
38338 return false;
38339 }
38340
38341 private boolean jj_3R_615() {
38342 Token xsp;
38343 xsp = jj_scanpos;
38344 if (jj_3R_626()) {
38345 jj_scanpos = xsp;
38346 if (jj_3R_627()) return true;
38347 }
38348 return false;
38349 }
38350
38351 private boolean jj_3R_535() {
38352 if (jj_scan_token(CC_ERROR)) return true;
38353 if (jj_3R_234()) return true;
38354 if (jj_scan_token(CC_END)) return true;
38355 return false;
38356 }
38357
38358 private boolean jj_3R_534() {
38359 if (jj_3R_323()) return true;
38360 return false;
38361 }
38362
38363 private boolean jj_3R_506() {
38364 Token xsp;
38365 xsp = jj_scanpos;
38366 if (jj_3R_534()) {
38367 jj_scanpos = xsp;
38368 if (jj_3R_535()) return true;
38369 }
38370 return false;
38371 }
38372
38373 private boolean jj_3R_474() {
38374 if (jj_scan_token(CC_ELSE)) return true;
38375 Token xsp;
38376 while (true) {
38377 xsp = jj_scanpos;
38378 if (jj_3R_506()) { jj_scanpos = xsp; break; }
38379 }
38380 return false;
38381 }
38382
38383 private boolean jj_3R_533() {
38384 if (jj_scan_token(CC_ERROR)) return true;
38385 if (jj_3R_234()) return true;
38386 if (jj_scan_token(CC_END)) return true;
38387 return false;
38388 }
38389
38390 private boolean jj_3R_590() {
38391 if (jj_3R_615()) return true;
38392 return false;
38393 }
38394
38395 private boolean jj_3R_532() {
38396 if (jj_3R_323()) return true;
38397 return false;
38398 }
38399
38400 private boolean jj_3R_505() {
38401 Token xsp;
38402 xsp = jj_scanpos;
38403 if (jj_3R_532()) {
38404 jj_scanpos = xsp;
38405 if (jj_3R_533()) return true;
38406 }
38407 return false;
38408 }
38409
38410 private boolean jj_3R_589() {
38411 if (jj_scan_token(NOT)) return true;
38412 if (jj_3R_484()) return true;
38413 return false;
38414 }
38415
38416 private boolean jj_3R_545() {
38417 Token xsp;
38418 xsp = jj_scanpos;
38419 if (jj_3R_589()) {
38420 jj_scanpos = xsp;
38421 if (jj_3R_590()) return true;
38422 }
38423 return false;
38424 }
38425
38426 private boolean jj_3R_473() {
38427 if (jj_scan_token(CC_ELSIF)) return true;
38428 if (jj_3R_344()) return true;
38429 if (jj_scan_token(CC_THEN)) return true;
38430 Token xsp;
38431 while (true) {
38432 xsp = jj_scanpos;
38433 if (jj_3R_505()) { jj_scanpos = xsp; break; }
38434 }
38435 return false;
38436 }
38437
38438 private boolean jj_3R_504() {
38439 if (jj_scan_token(CC_ERROR)) return true;
38440 if (jj_3R_234()) return true;
38441 if (jj_scan_token(CC_END)) return true;
38442 return false;
38443 }
38444
38445 private boolean jj_3R_254() {
38446 if (jj_3R_124()) return true;
38447 return false;
38448 }
38449
38450 private boolean jj_3R_503() {
38451 if (jj_3R_323()) return true;
38452 return false;
38453 }
38454
38455 private boolean jj_3R_472() {
38456 Token xsp;
38457 xsp = jj_scanpos;
38458 if (jj_3R_503()) {
38459 jj_scanpos = xsp;
38460 if (jj_3R_504()) return true;
38461 }
38462 return false;
38463 }
38464
38465 private boolean jj_3R_514() {
38466 if (jj_3R_545()) return true;
38467 return false;
38468 }
38469
38470 private boolean jj_3R_544() {
38471 if (jj_scan_token(17)) return true;
38472 return false;
38473 }
38474
38475 private boolean jj_3R_543() {
38476 if (jj_scan_token(16)) return true;
38477 return false;
38478 }
38479
38480 private boolean jj_3R_513() {
38481 Token xsp;
38482 xsp = jj_scanpos;
38483 if (jj_3R_543()) {
38484 jj_scanpos = xsp;
38485 if (jj_3R_544()) return true;
38486 }
38487 if (jj_3R_484()) return true;
38488 return false;
38489 }
38490
38491 private boolean jj_3R_427() {
38492 if (jj_scan_token(CC_IF)) return true;
38493 if (jj_3R_344()) return true;
38494 if (jj_scan_token(CC_THEN)) return true;
38495 Token xsp;
38496 while (true) {
38497 xsp = jj_scanpos;
38498 if (jj_3R_472()) { jj_scanpos = xsp; break; }
38499 }
38500 while (true) {
38501 xsp = jj_scanpos;
38502 if (jj_3R_473()) { jj_scanpos = xsp; break; }
38503 }
38504 while (true) {
38505 xsp = jj_scanpos;
38506 if (jj_3R_474()) { jj_scanpos = xsp; break; }
38507 }
38508 if (jj_scan_token(CC_END)) return true;
38509 return false;
38510 }
38511
38512 private boolean jj_3R_275() {
38513 if (jj_3R_323()) return true;
38514 return false;
38515 }
38516
38517 private boolean jj_3R_484() {
38518 Token xsp;
38519 xsp = jj_scanpos;
38520 if (jj_3R_513()) {
38521 jj_scanpos = xsp;
38522 if (jj_3R_514()) return true;
38523 }
38524 return false;
38525 }
38526
38527 private boolean jj_3R_385() {
38528 if (jj_3R_427()) return true;
38529 return false;
38530 }
38531
38532 private boolean jj_3R_192() {
38533 Token xsp;
38534 while (true) {
38535 xsp = jj_scanpos;
38536 if (jj_3R_275()) { jj_scanpos = xsp; break; }
38537 }
38538 return false;
38539 }
38540
38541 private boolean jj_3R_608() {
38542 if (jj_scan_token(MOD)) return true;
38543 return false;
38544 }
38545
38546 private boolean jj_3R_384() {
38547 if (jj_3R_426()) return true;
38548 return false;
38549 }
38550
38551 private boolean jj_3_18() {
38552 Token xsp;
38553 xsp = jj_scanpos;
38554 if (jj_scan_token(125)) {
38555 jj_scanpos = xsp;
38556 if (jj_scan_token(223)) return true;
38557 }
38558 if (jj_3R_120()) return true;
38559 return false;
38560 }
38561
38562 private boolean jj_3R_607() {
38563 if (jj_scan_token(1)) return true;
38564 return false;
38565 }
38566
38567 private boolean jj_3R_606() {
38568 if (jj_scan_token(20)) return true;
38569 return false;
38570 }
38571
38572 private boolean jj_3_17() {
38573 Token xsp;
38574 xsp = jj_scanpos;
38575 if (jj_scan_token(284)) {
38576 jj_scanpos = xsp;
38577 if (jj_scan_token(264)) return true;
38578 }
38579 if (jj_3R_120()) return true;
38580 xsp = jj_scanpos;
38581 if (jj_scan_token(152)) {
38582 jj_scanpos = xsp;
38583 if (jj_scan_token(51)) return true;
38584 }
38585 return false;
38586 }
38587
38588 private boolean jj_3R_605() {
38589 if (jj_scan_token(19)) return true;
38590 return false;
38591 }
38592
38593 private boolean jj_3R_383() {
38594 if (jj_3R_425()) return true;
38595 return false;
38596 }
38597
38598 private boolean jj_3R_382() {
38599 if (jj_3R_424()) return true;
38600 return false;
38601 }
38602
38603 private boolean jj_3R_570() {
38604 Token xsp;
38605 xsp = jj_scanpos;
38606 if (jj_3R_605()) {
38607 jj_scanpos = xsp;
38608 if (jj_3R_606()) {
38609 jj_scanpos = xsp;
38610 if (jj_3R_607()) {
38611 jj_scanpos = xsp;
38612 if (jj_3R_608()) return true;
38613 }
38614 }
38615 }
38616 if (jj_3R_484()) return true;
38617 return false;
38618 }
38619
38620 private boolean jj_3_20() {
38621 if (jj_3R_122()) return true;
38622 return false;
38623 }
38624
38625 private boolean jj_3R_307() {
38626 if (jj_3R_351()) return true;
38627 return false;
38628 }
38629
38630 private boolean jj_3_19() {
38631 if (jj_3R_121()) return true;
38632 return false;
38633 }
38634
38635 private boolean jj_3R_381() {
38636 if (jj_3R_118()) return true;
38637 return false;
38638 }
38639
38640 private boolean jj_3R_380() {
38641 if (jj_3R_153()) return true;
38642 return false;
38643 }
38644
38645 private boolean jj_3R_537() {
38646 if (jj_3R_484()) return true;
38647 Token xsp;
38648 while (true) {
38649 xsp = jj_scanpos;
38650 if (jj_3R_570()) { jj_scanpos = xsp; break; }
38651 }
38652 return false;
38653 }
38654
38655 private boolean jj_3_16() {
38656 if (jj_3R_119()) return true;
38657 return false;
38658 }
38659
38660 private boolean jj_3R_379() {
38661 if (jj_3R_423()) return true;
38662 return false;
38663 }
38664
38665 private boolean jj_3_15() {
38666 if (jj_3R_118()) return true;
38667 return false;
38668 }
38669
38670 private boolean jj_3R_252() {
38671 Token xsp;
38672 xsp = jj_scanpos;
38673 if (jj_scan_token(100)) {
38674 jj_scanpos = xsp;
38675 if (jj_scan_token(182)) return true;
38676 }
38677 return false;
38678 }
38679
38680 private boolean jj_3R_300() {
38681 if (jj_scan_token(18)) return true;
38682 if (jj_3R_133()) return true;
38683 return false;
38684 }
38685
38686 private boolean jj_3R_306() {
38687 if (jj_3R_174()) return true;
38688 return false;
38689 }
38690
38691 private boolean jj_3R_323() {
38692 Token xsp;
38693 xsp = jj_scanpos;
38694 if (jj_3R_379()) {
38695 jj_scanpos = xsp;
38696 if (jj_3_16()) {
38697 jj_scanpos = xsp;
38698 if (jj_3R_380()) {
38699 jj_scanpos = xsp;
38700 if (jj_3R_381()) {
38701 jj_scanpos = xsp;
38702 if (jj_3_19()) {
38703 jj_scanpos = xsp;
38704 if (jj_3_20()) {
38705 jj_scanpos = xsp;
38706 if (jj_3R_382()) {
38707 jj_scanpos = xsp;
38708 if (jj_3R_383()) {
38709 jj_scanpos = xsp;
38710 if (jj_3R_384()) {
38711 jj_scanpos = xsp;
38712 if (jj_3R_385()) return true;
38713 }
38714 }
38715 }
38716 }
38717 }
38718 }
38719 }
38720 }
38721 }
38722 return false;
38723 }
38724
38725 private boolean jj_3R_230() {
38726 if (jj_3R_133()) return true;
38727 Token xsp;
38728 while (true) {
38729 xsp = jj_scanpos;
38730 if (jj_3R_300()) { jj_scanpos = xsp; break; }
38731 }
38732 return false;
38733 }
38734
38735 private boolean jj_3R_253() {
38736 if (jj_scan_token(BEGIN)) return true;
38737 Token xsp;
38738 while (true) {
38739 xsp = jj_scanpos;
38740 if (jj_3R_306()) { jj_scanpos = xsp; break; }
38741 }
38742 xsp = jj_scanpos;
38743 if (jj_3R_307()) jj_scanpos = xsp;
38744 return false;
38745 }
38746
38747 private boolean jj_3R_573() {
38748 if (jj_scan_token(18)) return true;
38749 return false;
38750 }
38751
38752 private boolean jj_3R_572() {
38753 if (jj_scan_token(17)) return true;
38754 return false;
38755 }
38756
38757 private boolean jj_3R_571() {
38758 if (jj_scan_token(16)) return true;
38759 return false;
38760 }
38761
38762 private boolean jj_3R_251() {
38763 if (jj_scan_token(OR)) return true;
38764 if (jj_scan_token(REPLACE)) return true;
38765 return false;
38766 }
38767
38768 private boolean jj_3R_161() {
38769 Token xsp;
38770 xsp = jj_scanpos;
38771 if (jj_scan_token(152)) {
38772 jj_scanpos = xsp;
38773 if (jj_scan_token(51)) return true;
38774 }
38775 if (jj_3R_192()) return true;
38776 xsp = jj_scanpos;
38777 if (jj_3R_253()) jj_scanpos = xsp;
38778 if (jj_scan_token(END)) return true;
38779 xsp = jj_scanpos;
38780 if (jj_3R_254()) jj_scanpos = xsp;
38781 if (jj_scan_token(4)) return true;
38782 return false;
38783 }
38784
38785 private boolean jj_3R_538() {
38786 Token xsp;
38787 xsp = jj_scanpos;
38788 if (jj_3R_571()) {
38789 jj_scanpos = xsp;
38790 if (jj_3R_572()) {
38791 jj_scanpos = xsp;
38792 if (jj_3R_573()) return true;
38793 }
38794 }
38795 if (jj_3R_537()) return true;
38796 return false;
38797 }
38798
38799 private boolean jj_3R_160() {
38800 if (jj_3R_249()) return true;
38801 return false;
38802 }
38803
38804 private boolean jj_3R_271() {
38805 if (jj_3R_191()) return true;
38806 return false;
38807 }
38808
38809 private boolean jj_3R_508() {
38810 if (jj_3R_537()) return true;
38811 Token xsp;
38812 while (true) {
38813 xsp = jj_scanpos;
38814 if (jj_3R_538()) { jj_scanpos = xsp; break; }
38815 }
38816 return false;
38817 }
38818
38819 private boolean jj_3R_588() {
38820 if (jj_3R_183()) return true;
38821 return false;
38822 }
38823
38824 private boolean jj_3R_159() {
38825 if (jj_scan_token(CREATE)) return true;
38826 Token xsp;
38827 xsp = jj_scanpos;
38828 if (jj_3R_251()) jj_scanpos = xsp;
38829 xsp = jj_scanpos;
38830 if (jj_3R_252()) jj_scanpos = xsp;
38831 return false;
38832 }
38833
38834 private boolean jj_3R_202() {
38835 if (jj_3R_283()) return true;
38836 return false;
38837 }
38838
38839 private boolean jj_3R_587() {
38840 if (jj_scan_token(CHARACTER_LITERAL)) return true;
38841 return false;
38842 }
38843
38844 private boolean jj_3R_246() {
38845 Token xsp;
38846 xsp = jj_scanpos;
38847 if (jj_scan_token(100)) {
38848 jj_scanpos = xsp;
38849 if (jj_scan_token(182)) return true;
38850 }
38851 return false;
38852 }
38853
38854 private boolean jj_3R_250() {
38855 if (jj_3R_124()) return true;
38856 return false;
38857 }
38858
38859 private boolean jj_3R_542() {
38860 if (jj_scan_token(ESCAPE)) return true;
38861 Token xsp;
38862 xsp = jj_scanpos;
38863 if (jj_3R_587()) {
38864 jj_scanpos = xsp;
38865 if (jj_3R_588()) return true;
38866 }
38867 return false;
38868 }
38869
38870 private boolean jj_3R_104() {
38871 Token xsp;
38872 xsp = jj_scanpos;
38873 if (jj_3R_159()) jj_scanpos = xsp;
38874 xsp = jj_scanpos;
38875 if (jj_scan_token(209)) {
38876 jj_scanpos = xsp;
38877 if (jj_scan_token(284)) return true;
38878 }
38879 if (jj_scan_token(BODY)) return true;
38880 if (jj_3R_155()) return true;
38881 xsp = jj_scanpos;
38882 if (jj_3R_160()) {
38883 jj_scanpos = xsp;
38884 if (jj_3R_161()) return true;
38885 }
38886 return false;
38887 }
38888
38889 private boolean jj_3R_614() {
38890 if (jj_scan_token(ALL)) return true;
38891 return false;
38892 }
38893
38894 private boolean jj_3R_613() {
38895 if (jj_scan_token(DISTINCT)) return true;
38896 return false;
38897 }
38898
38899 private boolean jj_3R_586() {
38900 Token xsp;
38901 xsp = jj_scanpos;
38902 if (jj_3R_613()) {
38903 jj_scanpos = xsp;
38904 if (jj_3R_614()) return true;
38905 }
38906 return false;
38907 }
38908
38909 private boolean jj_3R_585() {
38910 if (jj_scan_token(UNION)) return true;
38911 return false;
38912 }
38913
38914 private boolean jj_3R_584() {
38915 if (jj_scan_token(INTERSECT)) return true;
38916 return false;
38917 }
38918
38919 private boolean jj_3R_124() {
38920 Token xsp;
38921 xsp = jj_scanpos;
38922 if (jj_scan_token(420)) {
38923 jj_scanpos = xsp;
38924 if (jj_scan_token(428)) {
38925 jj_scanpos = xsp;
38926 if (jj_3R_202()) {
38927 jj_scanpos = xsp;
38928 if (jj_scan_token(35)) {
38929 jj_scanpos = xsp;
38930 if (jj_scan_token(38)) {
38931 jj_scanpos = xsp;
38932 if (jj_scan_token(39)) {
38933 jj_scanpos = xsp;
38934 if (jj_scan_token(40)) {
38935 jj_scanpos = xsp;
38936 if (jj_scan_token(41)) {
38937 jj_scanpos = xsp;
38938 if (jj_scan_token(46)) {
38939 jj_scanpos = xsp;
38940 if (jj_scan_token(47)) {
38941 jj_scanpos = xsp;
38942 if (jj_scan_token(48)) {
38943 jj_scanpos = xsp;
38944 if (jj_scan_token(49)) {
38945 jj_scanpos = xsp;
38946 if (jj_scan_token(50)) {
38947 jj_scanpos = xsp;
38948 if (jj_scan_token(51)) {
38949 jj_scanpos = xsp;
38950 if (jj_scan_token(52)) {
38951 jj_scanpos = xsp;
38952 if (jj_scan_token(56)) {
38953 jj_scanpos = xsp;
38954 if (jj_scan_token(58)) {
38955 jj_scanpos = xsp;
38956 if (jj_scan_token(59)) {
38957 jj_scanpos = xsp;
38958 if (jj_scan_token(60)) {
38959 jj_scanpos = xsp;
38960 if (jj_scan_token(61)) {
38961 jj_scanpos = xsp;
38962 if (jj_scan_token(63)) {
38963 jj_scanpos = xsp;
38964 if (jj_scan_token(66)) {
38965 jj_scanpos = xsp;
38966 if (jj_scan_token(67)) {
38967 jj_scanpos = xsp;
38968 if (jj_scan_token(68)) {
38969 jj_scanpos = xsp;
38970 if (jj_scan_token(69)) {
38971 jj_scanpos = xsp;
38972 if (jj_scan_token(71)) {
38973 jj_scanpos = xsp;
38974 if (jj_scan_token(77)) {
38975 jj_scanpos = xsp;
38976 if (jj_scan_token(78)) {
38977 jj_scanpos = xsp;
38978 if (jj_scan_token(79)) {
38979 jj_scanpos = xsp;
38980 if (jj_scan_token(83)) {
38981 jj_scanpos = xsp;
38982 if (jj_scan_token(85)) {
38983 jj_scanpos = xsp;
38984 if (jj_scan_token(88)) {
38985 jj_scanpos = xsp;
38986 if (jj_scan_token(90)) {
38987 jj_scanpos = xsp;
38988 if (jj_scan_token(91)) {
38989 jj_scanpos = xsp;
38990 if (jj_scan_token(92)) {
38991 jj_scanpos = xsp;
38992 if (jj_scan_token(93)) {
38993 jj_scanpos = xsp;
38994 if (jj_scan_token(94)) {
38995 jj_scanpos = xsp;
38996 if (jj_scan_token(97)) {
38997 jj_scanpos = xsp;
38998 if (jj_scan_token(98)) {
38999 jj_scanpos = xsp;
39000 if (jj_scan_token(99)) {
39001 jj_scanpos = xsp;
39002 if (jj_scan_token(102)) {
39003 jj_scanpos = xsp;
39004 if (jj_scan_token(103)) {
39005 jj_scanpos = xsp;
39006 if (jj_scan_token(108)) {
39007 jj_scanpos = xsp;
39008 if (jj_scan_token(110)) {
39009 jj_scanpos = xsp;
39010 if (jj_scan_token(111)) {
39011 jj_scanpos = xsp;
39012 if (jj_scan_token(112)) {
39013 jj_scanpos = xsp;
39014 if (jj_scan_token(118)) {
39015 jj_scanpos = xsp;
39016 if (jj_scan_token(120)) {
39017 jj_scanpos = xsp;
39018 if (jj_scan_token(121)) {
39019 jj_scanpos = xsp;
39020 if (jj_scan_token(122)) {
39021 jj_scanpos = xsp;
39022 if (jj_scan_token(124)) {
39023 jj_scanpos = xsp;
39024 if (jj_scan_token(127)) {
39025 jj_scanpos = xsp;
39026 if (jj_scan_token(128)) {
39027 jj_scanpos = xsp;
39028 if (jj_scan_token(131)) {
39029 jj_scanpos = xsp;
39030 if (jj_scan_token(135)) {
39031 jj_scanpos = xsp;
39032 if (jj_scan_token(137)) {
39033 jj_scanpos = xsp;
39034 if (jj_scan_token(139)) {
39035 jj_scanpos = xsp;
39036 if (jj_scan_token(144)) {
39037 jj_scanpos = xsp;
39038 if (jj_scan_token(146)) {
39039 jj_scanpos = xsp;
39040 if (jj_scan_token(147)) {
39041 jj_scanpos = xsp;
39042 if (jj_scan_token(148)) {
39043 jj_scanpos = xsp;
39044 if (jj_scan_token(150)) {
39045 jj_scanpos = xsp;
39046 if (jj_scan_token(152)) {
39047 jj_scanpos = xsp;
39048 if (jj_scan_token(156)) {
39049 jj_scanpos = xsp;
39050 if (jj_scan_token(158)) {
39051 jj_scanpos = xsp;
39052 if (jj_scan_token(159)) {
39053 jj_scanpos = xsp;
39054 if (jj_scan_token(160)) {
39055 jj_scanpos = xsp;
39056 if (jj_scan_token(161)) {
39057 jj_scanpos = xsp;
39058 if (jj_scan_token(167)) {
39059 jj_scanpos = xsp;
39060 if (jj_scan_token(171)) {
39061 jj_scanpos = xsp;
39062 if (jj_scan_token(172)) {
39063 jj_scanpos = xsp;
39064 if (jj_scan_token(175)) {
39065 jj_scanpos = xsp;
39066 if (jj_scan_token(178)) {
39067 jj_scanpos = xsp;
39068 if (jj_scan_token(181)) {
39069 jj_scanpos = xsp;
39070 if (jj_scan_token(183)) {
39071 jj_scanpos = xsp;
39072 if (jj_scan_token(184)) {
39073 jj_scanpos = xsp;
39074 if (jj_scan_token(185)) {
39075 jj_scanpos = xsp;
39076 if (jj_scan_token(187)) {
39077 jj_scanpos = xsp;
39078 if (jj_scan_token(192)) {
39079 jj_scanpos = xsp;
39080 if (jj_scan_token(194)) {
39081 jj_scanpos = xsp;
39082 if (jj_scan_token(195)) {
39083 jj_scanpos = xsp;
39084 if (jj_scan_token(197)) {
39085 jj_scanpos = xsp;
39086 if (jj_scan_token(188)) {
39087 jj_scanpos = xsp;
39088 if (jj_scan_token(189)) {
39089 jj_scanpos = xsp;
39090 if (jj_scan_token(190)) {
39091 jj_scanpos = xsp;
39092 if (jj_scan_token(191)) {
39093 jj_scanpos = xsp;
39094 if (jj_scan_token(201)) {
39095 jj_scanpos = xsp;
39096 if (jj_scan_token(202)) {
39097 jj_scanpos = xsp;
39098 if (jj_scan_token(203)) {
39099 jj_scanpos = xsp;
39100 if (jj_scan_token(204)) {
39101 jj_scanpos = xsp;
39102 if (jj_scan_token(207)) {
39103 jj_scanpos = xsp;
39104 if (jj_scan_token(212)) {
39105 jj_scanpos = xsp;
39106 if (jj_scan_token(215)) {
39107 jj_scanpos = xsp;
39108 if (jj_scan_token(216)) {
39109 jj_scanpos = xsp;
39110 if (jj_scan_token(217)) {
39111 jj_scanpos = xsp;
39112 if (jj_scan_token(220)) {
39113 jj_scanpos = xsp;
39114 if (jj_scan_token(222)) {
39115 jj_scanpos = xsp;
39116 if (jj_scan_token(221)) {
39117 jj_scanpos = xsp;
39118 if (jj_scan_token(224)) {
39119 jj_scanpos = xsp;
39120 if (jj_scan_token(225)) {
39121 jj_scanpos = xsp;
39122 if (jj_scan_token(227)) {
39123 jj_scanpos = xsp;
39124 if (jj_scan_token(246)) {
39125 jj_scanpos = xsp;
39126 if (jj_scan_token(250)) {
39127 jj_scanpos = xsp;
39128 if (jj_scan_token(252)) {
39129 jj_scanpos = xsp;
39130 if (jj_scan_token(255)) {
39131 jj_scanpos = xsp;
39132 if (jj_scan_token(256)) {
39133 jj_scanpos = xsp;
39134 if (jj_scan_token(258)) {
39135 jj_scanpos = xsp;
39136 if (jj_scan_token(259)) {
39137 jj_scanpos = xsp;
39138 if (jj_scan_token(260)) {
39139 jj_scanpos = xsp;
39140 if (jj_scan_token(261)) {
39141 jj_scanpos = xsp;
39142 if (jj_scan_token(263)) {
39143 jj_scanpos = xsp;
39144 if (jj_scan_token(267)) {
39145 jj_scanpos = xsp;
39146 if (jj_scan_token(268)) {
39147 jj_scanpos = xsp;
39148 if (jj_scan_token(269)) {
39149 jj_scanpos = xsp;
39150 if (jj_scan_token(271)) {
39151 jj_scanpos = xsp;
39152 if (jj_scan_token(273)) {
39153 jj_scanpos = xsp;
39154 if (jj_scan_token(280)) {
39155 jj_scanpos = xsp;
39156 if (jj_scan_token(282)) {
39157 jj_scanpos = xsp;
39158 if (jj_scan_token(284)) {
39159 jj_scanpos = xsp;
39160 if (jj_scan_token(285)) {
39161 jj_scanpos = xsp;
39162 if (jj_scan_token(297)) {
39163 jj_scanpos = xsp;
39164 if (jj_scan_token(298)) {
39165 jj_scanpos = xsp;
39166 if (jj_scan_token(299)) {
39167 jj_scanpos = xsp;
39168 if (jj_scan_token(303)) {
39169 jj_scanpos = xsp;
39170 if (jj_scan_token(305)) {
39171 jj_scanpos = xsp;
39172 if (jj_scan_token(308)) {
39173 jj_scanpos = xsp;
39174 if (jj_scan_token(318)) {
39175 jj_scanpos = xsp;
39176 if (jj_scan_token(292)) {
39177 jj_scanpos = xsp;
39178 if (jj_scan_token(432)) {
39179 jj_scanpos = xsp;
39180 if (jj_scan_token(429)) {
39181 jj_scanpos = xsp;
39182 if (jj_scan_token(430)) {
39183 jj_scanpos = xsp;
39184 if (jj_scan_token(431)) return true;
39185 }
39186 }
39187 }
39188 }
39189 }
39190 }
39191 }
39192 }
39193 }
39194 }
39195 }
39196 }
39197 }
39198 }
39199 }
39200 }
39201 }
39202 }
39203 }
39204 }
39205 }
39206 }
39207 }
39208 }
39209 }
39210 }
39211 }
39212 }
39213 }
39214 }
39215 }
39216 }
39217 }
39218 }
39219 }
39220 }
39221 }
39222 }
39223 }
39224 }
39225 }
39226 }
39227 }
39228 }
39229 }
39230 }
39231 }
39232 }
39233 }
39234 }
39235 }
39236 }
39237 }
39238 }
39239 }
39240 }
39241 }
39242 }
39243 }
39244 }
39245 }
39246 }
39247 }
39248 }
39249 }
39250 }
39251 }
39252 }
39253 }
39254 }
39255 }
39256 }
39257 }
39258 }
39259 }
39260 }
39261 }
39262 }
39263 }
39264 }
39265 }
39266 }
39267 }
39268 }
39269 }
39270 }
39271 }
39272 }
39273 }
39274 }
39275 }
39276 }
39277 }
39278 }
39279 }
39280 }
39281 }
39282 }
39283 }
39284 }
39285 }
39286 }
39287 }
39288 }
39289 }
39290 }
39291 }
39292 }
39293 }
39294 }
39295 }
39296 }
39297 }
39298 }
39299 }
39300 }
39301 }
39302 }
39303 }
39304 }
39305 }
39306 }
39307 }
39308 }
39309 }
39310 }
39311 }
39312 }
39313 }
39314 }
39315 }
39316 return false;
39317 }
39318
39319 private boolean jj_3R_583() {
39320 if (jj_scan_token(EXCEPT)) return true;
39321 return false;
39322 }
39323
39324 private boolean jj_3R_158() {
39325 Token xsp;
39326 xsp = jj_scanpos;
39327 if (jj_scan_token(152)) {
39328 jj_scanpos = xsp;
39329 if (jj_scan_token(51)) return true;
39330 }
39331 if (jj_3R_192()) return true;
39332 if (jj_scan_token(END)) return true;
39333 xsp = jj_scanpos;
39334 if (jj_3R_250()) jj_scanpos = xsp;
39335 if (jj_scan_token(4)) return true;
39336 return false;
39337 }
39338
39339 private boolean jj_3R_612() {
39340 if (jj_scan_token(OF)) return true;
39341 return false;
39342 }
39343
39344 private boolean jj_3R_541() {
39345 if (jj_scan_token(MULTISET)) return true;
39346 Token xsp;
39347 xsp = jj_scanpos;
39348 if (jj_3R_583()) {
39349 jj_scanpos = xsp;
39350 if (jj_3R_584()) {
39351 jj_scanpos = xsp;
39352 if (jj_3R_585()) return true;
39353 }
39354 }
39355 xsp = jj_scanpos;
39356 if (jj_3R_586()) jj_scanpos = xsp;
39357 return false;
39358 }
39359
39360 private boolean jj_3R_157() {
39361 if (jj_3R_249()) return true;
39362 return false;
39363 }
39364
39365 private boolean jj_3R_245() {
39366 if (jj_scan_token(OR)) return true;
39367 if (jj_scan_token(REPLACE)) return true;
39368 return false;
39369 }
39370
39371 private boolean jj_3R_611() {
39372 if (jj_scan_token(SUBMULTISET)) return true;
39373 return false;
39374 }
39375
39376 private boolean jj_3R_248() {
39377 if (jj_3R_239()) return true;
39378 return false;
39379 }
39380
39381 private boolean jj_3R_610() {
39382 if (jj_scan_token(MEMBER)) return true;
39383 return false;
39384 }
39385
39386 private boolean jj_3R_156() {
39387 Token xsp;
39388 xsp = jj_scanpos;
39389 if (jj_3R_247()) {
39390 jj_scanpos = xsp;
39391 if (jj_3R_248()) return true;
39392 }
39393 return false;
39394 }
39395
39396 private boolean jj_3R_247() {
39397 if (jj_scan_token(AUTHID)) return true;
39398 Token xsp;
39399 xsp = jj_scanpos;
39400 if (jj_scan_token(37)) {
39401 jj_scanpos = xsp;
39402 if (jj_scan_token(36)) return true;
39403 }
39404 return false;
39405 }
39406
39407 private boolean jj_3R_582() {
39408 Token xsp;
39409 xsp = jj_scanpos;
39410 if (jj_3R_610()) {
39411 jj_scanpos = xsp;
39412 if (jj_3R_611()) return true;
39413 }
39414 xsp = jj_scanpos;
39415 if (jj_3R_612()) jj_scanpos = xsp;
39416 return false;
39417 }
39418
39419 private boolean jj_3R_581() {
39420 if (jj_scan_token(FROM)) return true;
39421 return false;
39422 }
39423
39424 private boolean jj_3R_154() {
39425 if (jj_scan_token(CREATE)) return true;
39426 Token xsp;
39427 xsp = jj_scanpos;
39428 if (jj_3R_245()) jj_scanpos = xsp;
39429 xsp = jj_scanpos;
39430 if (jj_3R_246()) jj_scanpos = xsp;
39431 return false;
39432 }
39433
39434 private boolean jj_3R_580() {
39435 if (jj_scan_token(LIKE)) return true;
39436 return false;
39437 }
39438
39439 private boolean jj_3R_579() {
39440 if (jj_scan_token(BETWEEN)) return true;
39441 return false;
39442 }
39443
39444 private boolean jj_3R_578() {
39445 if (jj_scan_token(IN)) return true;
39446 return false;
39447 }
39448
39449 private boolean jj_3R_103() {
39450 Token xsp;
39451 xsp = jj_scanpos;
39452 if (jj_3R_154()) jj_scanpos = xsp;
39453 if (jj_scan_token(PACKAGE)) return true;
39454 if (jj_3R_155()) return true;
39455 while (true) {
39456 xsp = jj_scanpos;
39457 if (jj_3R_156()) { jj_scanpos = xsp; break; }
39458 }
39459 xsp = jj_scanpos;
39460 if (jj_3R_157()) {
39461 jj_scanpos = xsp;
39462 if (jj_3R_158()) return true;
39463 }
39464 return false;
39465 }
39466
39467 private boolean jj_3R_609() {
39468 if (jj_scan_token(15)) return true;
39469 return false;
39470 }
39471
39472 private boolean jj_3R_577() {
39473 if (jj_scan_token(NOT)) return true;
39474 return false;
39475 }
39476
39477 private boolean jj_3R_576() {
39478 if (jj_scan_token(10)) return true;
39479 return false;
39480 }
39481
39482 private boolean jj_3R_575() {
39483 if (jj_scan_token(15)) return true;
39484 return false;
39485 }
39486
39487 private boolean jj_3R_540() {
39488 Token xsp;
39489 xsp = jj_scanpos;
39490 if (jj_3R_577()) jj_scanpos = xsp;
39491 xsp = jj_scanpos;
39492 if (jj_3R_578()) {
39493 jj_scanpos = xsp;
39494 if (jj_3R_579()) {
39495 jj_scanpos = xsp;
39496 if (jj_3R_580()) {
39497 jj_scanpos = xsp;
39498 if (jj_3R_581()) {
39499 jj_scanpos = xsp;
39500 if (jj_3R_582()) return true;
39501 }
39502 }
39503 }
39504 }
39505 return false;
39506 }
39507
39508 private boolean jj_3R_574() {
39509 if (jj_scan_token(14)) return true;
39510 Token xsp;
39511 xsp = jj_scanpos;
39512 if (jj_3R_609()) jj_scanpos = xsp;
39513 return false;
39514 }
39515
39516 private boolean jj_3R_117() {
39517 if (jj_scan_token(DECLARE)) return true;
39518 if (jj_3R_192()) return true;
39519 return false;
39520 }
39521
39522 private boolean jj_3R_539() {
39523 Token xsp;
39524 xsp = jj_scanpos;
39525 if (jj_3R_574()) {
39526 jj_scanpos = xsp;
39527 if (jj_3R_575()) return true;
39528 }
39529 xsp = jj_scanpos;
39530 if (jj_3R_576()) jj_scanpos = xsp;
39531 return false;
39532 }
39533
39534 private boolean jj_3R_322() {
39535 if (jj_3R_351()) return true;
39536 return false;
39537 }
39538
39539 private boolean jj_3R_321() {
39540 if (jj_3R_174()) return true;
39541 return false;
39542 }
39543
39544 private boolean jj_3R_509() {
39545 Token xsp;
39546 xsp = jj_scanpos;
39547 if (jj_3R_539()) {
39548 jj_scanpos = xsp;
39549 if (jj_3R_540()) {
39550 jj_scanpos = xsp;
39551 if (jj_3R_541()) return true;
39552 }
39553 }
39554 if (jj_3R_508()) return true;
39555 xsp = jj_scanpos;
39556 if (jj_3R_542()) jj_scanpos = xsp;
39557 return false;
39558 }
39559
39560 private boolean jj_3R_116() {
39561 if (jj_3R_191()) return true;
39562 return false;
39563 }
39564
39565 private boolean jj_3_14() {
39566 Token xsp;
39567 while (true) {
39568 xsp = jj_scanpos;
39569 if (jj_3R_116()) { jj_scanpos = xsp; break; }
39570 }
39571 xsp = jj_scanpos;
39572 if (jj_3R_117()) jj_scanpos = xsp;
39573 if (jj_scan_token(BEGIN)) return true;
39574 return false;
39575 }
39576
39577 private boolean jj_3R_320() {
39578 if (jj_scan_token(DECLARE)) return true;
39579 if (jj_3R_192()) return true;
39580 return false;
39581 }
39582
39583 private boolean jj_3R_482() {
39584 if (jj_3R_508()) return true;
39585 Token xsp;
39586 while (true) {
39587 xsp = jj_scanpos;
39588 if (jj_3R_509()) { jj_scanpos = xsp; break; }
39589 }
39590 return false;
39591 }
39592
39593 private boolean jj_3R_272() {
39594 Token xsp;
39595 xsp = jj_scanpos;
39596 if (jj_3R_320()) jj_scanpos = xsp;
39597 if (jj_scan_token(BEGIN)) return true;
39598 while (true) {
39599 xsp = jj_scanpos;
39600 if (jj_3R_321()) { jj_scanpos = xsp; break; }
39601 }
39602 xsp = jj_scanpos;
39603 if (jj_3R_322()) jj_scanpos = xsp;
39604 if (jj_scan_token(END)) return true;
39605 xsp = jj_scanpos;
39606 if (jj_scan_token(420)) jj_scanpos = xsp;
39607 return false;
39608 }
39609
39610 private boolean jj_3R_512() {
39611 if (jj_scan_token(IS)) return true;
39612 return false;
39613 }
39614
39615 private boolean jj_3R_511() {
39616 if (jj_scan_token(13)) return true;
39617 if (jj_scan_token(10)) return true;
39618 return false;
39619 }
39620
39621 private boolean jj_3R_186() {
39622 Token xsp;
39623 while (true) {
39624 xsp = jj_scanpos;
39625 if (jj_3R_271()) { jj_scanpos = xsp; break; }
39626 }
39627 if (jj_3R_272()) return true;
39628 if (jj_scan_token(4)) return true;
39629 return false;
39630 }
39631
39632 private boolean jj_3R_510() {
39633 if (jj_scan_token(10)) return true;
39634 return false;
39635 }
39636
39637 private boolean jj_3R_483() {
39638 Token xsp;
39639 xsp = jj_scanpos;
39640 if (jj_3R_510()) {
39641 jj_scanpos = xsp;
39642 if (jj_3R_511()) {
39643 jj_scanpos = xsp;
39644 if (jj_3R_512()) return true;
39645 }
39646 }
39647 if (jj_3R_482()) return true;
39648 return false;
39649 }
39650
39651 private boolean jj_3R_113() {
39652 Token xsp;
39653 xsp = jj_scanpos;
39654 if (jj_3R_186()) {
39655 jj_scanpos = xsp;
39656 if (jj_3_15()) return true;
39657 }
39658 return false;
39659 }
39660
39661 private boolean jj_3R_437() {
39662 if (jj_3R_482()) return true;
39663 Token xsp;
39664 while (true) {
39665 xsp = jj_scanpos;
39666 if (jj_3R_483()) { jj_scanpos = xsp; break; }
39667 }
39668 return false;
39669 }
39670
39671 private boolean jj_3R_438() {
39672 if (jj_scan_token(AND)) return true;
39673 if (jj_3R_437()) return true;
39674 return false;
39675 }
39676
39677 private boolean jj_3R_395() {
39678 if (jj_3R_437()) return true;
39679 Token xsp;
39680 while (true) {
39681 xsp = jj_scanpos;
39682 if (jj_3R_438()) { jj_scanpos = xsp; break; }
39683 }
39684 return false;
39685 }
39686
39687 private boolean jj_3R_396() {
39688 if (jj_scan_token(OR)) return true;
39689 if (jj_3R_395()) return true;
39690 return false;
39691 }
39692
39693 private boolean jj_3R_344() {
39694 if (jj_3R_395()) return true;
39695 Token xsp;
39696 while (true) {
39697 xsp = jj_scanpos;
39698 if (jj_3R_396()) { jj_scanpos = xsp; break; }
39699 }
39700 return false;
39701 }
39702
39703 private boolean jj_3R_189() {
39704 if (jj_scan_token(3)) return true;
39705 if (jj_scan_token(ATTACH)) return true;
39706 return false;
39707 }
39708
39709 private boolean jj_3R_237() {
39710 if (jj_scan_token(3)) return true;
39711 if (jj_3R_234()) return true;
39712 return false;
39713 }
39714
39715 private boolean jj_3R_235() {
39716 if (jj_scan_token(AT)) return true;
39717 if (jj_scan_token(TIME)) return true;
39718 if (jj_scan_token(ZONE)) return true;
39719 if (jj_3R_133()) return true;
39720 return false;
39721 }
39722
39723 private boolean jj_3R_140() {
39724 Token xsp;
39725 xsp = jj_scanpos;
39726 if (jj_scan_token(390)) {
39727 jj_scanpos = xsp;
39728 if (jj_scan_token(391)) return true;
39729 }
39730 if (jj_scan_token(5)) return true;
39731 if (jj_3R_234()) return true;
39732 xsp = jj_scanpos;
39733 if (jj_3R_235()) jj_scanpos = xsp;
39734 if (jj_scan_token(AS)) return true;
39735 if (jj_3R_236()) return true;
39736 if (jj_scan_token(7)) return true;
39737 while (true) {
39738 xsp = jj_scanpos;
39739 if (jj_3R_237()) { jj_scanpos = xsp; break; }
39740 }
39741 return false;
39742 }
39743
39744 private boolean jj_3R_229() {
39745 if (jj_3R_230()) return true;
39746 return false;
39747 }
39748
39749 private boolean jj_3R_228() {
39750 Token xsp;
39751 xsp = jj_scanpos;
39752 if (jj_scan_token(399)) {
39753 jj_scanpos = xsp;
39754 if (jj_scan_token(400)) {
39755 jj_scanpos = xsp;
39756 if (jj_scan_token(395)) return true;
39757 }
39758 }
39759 return false;
39760 }
39761
39762 private boolean jj_3R_115() {
39763 Token xsp;
39764 xsp = jj_scanpos;
39765 if (jj_scan_token(2)) {
39766 jj_scanpos = xsp;
39767 if (jj_scan_token(377)) {
39768 jj_scanpos = xsp;
39769 if (jj_scan_token(74)) {
39770 jj_scanpos = xsp;
39771 if (jj_scan_token(78)) {
39772 jj_scanpos = xsp;
39773 if (jj_scan_token(379)) {
39774 jj_scanpos = xsp;
39775 if (jj_scan_token(380)) {
39776 jj_scanpos = xsp;
39777 if (jj_scan_token(381)) {
39778 jj_scanpos = xsp;
39779 if (jj_scan_token(111)) {
39780 jj_scanpos = xsp;
39781 if (jj_scan_token(113)) {
39782 jj_scanpos = xsp;
39783 if (jj_scan_token(382)) {
39784 jj_scanpos = xsp;
39785 if (jj_scan_token(383)) {
39786 jj_scanpos = xsp;
39787 if (jj_scan_token(221)) {
39788 jj_scanpos = xsp;
39789 if (jj_scan_token(384)) {
39790 jj_scanpos = xsp;
39791 if (jj_scan_token(385)) {
39792 jj_scanpos = xsp;
39793 if (jj_scan_token(253)) {
39794 jj_scanpos = xsp;
39795 if (jj_scan_token(294)) {
39796 jj_scanpos = xsp;
39797 if (jj_scan_token(295)) {
39798 jj_scanpos = xsp;
39799 if (jj_scan_token(261)) {
39800 jj_scanpos = xsp;
39801 if (jj_scan_token(386)) {
39802 jj_scanpos = xsp;
39803 if (jj_scan_token(387)) {
39804 jj_scanpos = xsp;
39805 if (jj_scan_token(388)) {
39806 jj_scanpos = xsp;
39807 if (jj_scan_token(75)) {
39808 jj_scanpos = xsp;
39809 if (jj_scan_token(129)) {
39810 jj_scanpos = xsp;
39811 if (jj_scan_token(240)) {
39812 jj_scanpos = xsp;
39813 if (jj_scan_token(99)) {
39814 jj_scanpos = xsp;
39815 if (jj_scan_token(420)) {
39816 jj_scanpos = xsp;
39817 if (jj_3R_189()) return true;
39818 }
39819 }
39820 }
39821 }
39822 }
39823 }
39824 }
39825 }
39826 }
39827 }
39828 }
39829 }
39830 }
39831 }
39832 }
39833 }
39834 }
39835 }
39836 }
39837 }
39838 }
39839 }
39840 }
39841 }
39842 }
39843 }
39844 if (jj_3R_190()) return true;
39845 return false;
39846 }
39847
39848 private boolean jj_3R_138() {
39849 if (jj_scan_token(TRIM)) return true;
39850 if (jj_scan_token(5)) return true;
39851 Token xsp;
39852 xsp = jj_scanpos;
39853 if (jj_3R_228()) jj_scanpos = xsp;
39854 xsp = jj_scanpos;
39855 if (jj_3R_229()) jj_scanpos = xsp;
39856 if (jj_scan_token(FROM)) return true;
39857 if (jj_3R_230()) return true;
39858 if (jj_scan_token(7)) return true;
39859 return false;
39860 }
39861
39862 private boolean jj_3R_114() {
39863 if (jj_3R_187()) return true;
39864 if (jj_3R_188()) return true;
39865 return false;
39866 }
39867
39868 private boolean jj_3_13() {
39869 if (jj_3R_115()) return true;
39870 return false;
39871 }
39872
39873 private boolean jj_3_12() {
39874 if (jj_3R_114()) return true;
39875 return false;
39876 }
39877
39878 private boolean jj_3_11() {
39879 if (jj_3R_113()) return true;
39880 return false;
39881 }
39882
39883 private boolean jj_3_10() {
39884 if (jj_3R_112()) return true;
39885 return false;
39886 }
39887
39888 private boolean jj_3_9() {
39889 if (jj_3R_111()) return true;
39890 return false;
39891 }
39892
39893 private boolean jj_3_8() {
39894 if (jj_3R_110()) return true;
39895 return false;
39896 }
39897
39898 private boolean jj_3_7() {
39899 if (jj_3R_109()) return true;
39900 return false;
39901 }
39902
39903 private boolean jj_3_6() {
39904 if (jj_3R_108()) return true;
39905 return false;
39906 }
39907
39908 private boolean jj_3_5() {
39909 if (jj_3R_107()) return true;
39910 return false;
39911 }
39912
39913 private boolean jj_3_4() {
39914 if (jj_3R_106()) return true;
39915 return false;
39916 }
39917
39918 private boolean jj_3_3() {
39919 if (jj_3R_105()) return true;
39920 return false;
39921 }
39922
39923 private boolean jj_3_2() {
39924 if (jj_3R_104()) return true;
39925 return false;
39926 }
39927
39928 private boolean jj_3_1() {
39929 if (jj_3R_103()) return true;
39930 return false;
39931 }
39932
39933 private boolean jj_3R_233() {
39934 if (jj_scan_token(ELSE)) return true;
39935 if (jj_3R_234()) return true;
39936 return false;
39937 }
39938
39939 private boolean jj_3R_232() {
39940 if (jj_scan_token(WHEN)) return true;
39941 if (jj_3R_234()) return true;
39942 if (jj_scan_token(THEN)) return true;
39943 if (jj_3R_234()) return true;
39944 return false;
39945 }
39946
39947 private boolean jj_3R_231() {
39948 if (jj_3R_234()) return true;
39949 return false;
39950 }
39951
39952 private boolean jj_3R_139() {
39953 if (jj_scan_token(CASE)) return true;
39954 Token xsp;
39955 xsp = jj_scanpos;
39956 if (jj_3R_231()) jj_scanpos = xsp;
39957 if (jj_3R_232()) return true;
39958 while (true) {
39959 xsp = jj_scanpos;
39960 if (jj_3R_232()) { jj_scanpos = xsp; break; }
39961 }
39962 xsp = jj_scanpos;
39963 if (jj_3R_233()) jj_scanpos = xsp;
39964 if (jj_scan_token(END)) return true;
39965 return false;
39966 }
39967
39968 private boolean jj_3R_343() {
39969 if (jj_3R_133()) return true;
39970 if (jj_scan_token(9)) return true;
39971 if (jj_scan_token(10)) return true;
39972 if (jj_3R_234()) return true;
39973 return false;
39974 }
39975
39976 private boolean jj_3R_398() {
39977 if (jj_scan_token(CC_ELSE)) return true;
39978 if (jj_3R_234()) return true;
39979 return false;
39980 }
39981
39982 private boolean jj_3R_397() {
39983 if (jj_scan_token(CC_ELSIF)) return true;
39984 if (jj_3R_344()) return true;
39985 if (jj_scan_token(CC_THEN)) return true;
39986 if (jj_3R_234()) return true;
39987 return false;
39988 }
39989
39990 private boolean jj_3R_109() {
39991 if (jj_scan_token(ALTER)) return true;
39992 if (jj_scan_token(TRIGGER)) return true;
39993 if (jj_3R_180()) return true;
39994 if (jj_scan_token(4)) return true;
39995 return false;
39996 }
39997
39998 private boolean jj_3R_319() {
39999 if (jj_3R_378()) return true;
40000 return false;
40001 }
40002
40003 private boolean jj_3R_345() {
40004 if (jj_scan_token(CC_IF)) return true;
40005 if (jj_3R_344()) return true;
40006 if (jj_scan_token(CC_THEN)) return true;
40007 if (jj_3R_234()) return true;
40008 Token xsp;
40009 while (true) {
40010 xsp = jj_scanpos;
40011 if (jj_3R_397()) { jj_scanpos = xsp; break; }
40012 }
40013 while (true) {
40014 xsp = jj_scanpos;
40015 if (jj_3R_398()) { jj_scanpos = xsp; break; }
40016 }
40017 if (jj_scan_token(CC_END)) return true;
40018 return false;
40019 }
40020
40021 private boolean jj_3_45() {
40022 if (jj_3R_133()) return true;
40023 if (jj_scan_token(9)) return true;
40024 if (jj_scan_token(10)) return true;
40025 return false;
40026 }
40027
40028 private boolean jj_3R_318() {
40029 if (jj_3R_187()) return true;
40030 return false;
40031 }
40032
40033 private boolean jj_3R_268() {
40034 Token xsp;
40035 xsp = jj_scanpos;
40036 if (jj_3R_318()) {
40037 jj_scanpos = xsp;
40038 if (jj_3R_319()) return true;
40039 }
40040 return false;
40041 }
40042
40043 private boolean jj_3R_303() {
40044 if (jj_3R_345()) return true;
40045 return false;
40046 }
40047
40048 private boolean jj_3R_302() {
40049 if (jj_3R_344()) return true;
40050 return false;
40051 }
40052
40053 private boolean jj_3R_301() {
40054 if (jj_3R_343()) return true;
40055 return false;
40056 }
40057
40058 private boolean jj_3R_234() {
40059 Token xsp;
40060 xsp = jj_scanpos;
40061 if (jj_3R_301()) {
40062 jj_scanpos = xsp;
40063 if (jj_3R_302()) {
40064 jj_scanpos = xsp;
40065 if (jj_3R_303()) return true;
40066 }
40067 }
40068 return false;
40069 }
40070
40071 private boolean jj_3R_378() {
40072 Token xsp;
40073 xsp = jj_scanpos;
40074 if (jj_scan_token(361)) {
40075 jj_scanpos = xsp;
40076 if (jj_scan_token(360)) {
40077 jj_scanpos = xsp;
40078 if (jj_scan_token(355)) {
40079 jj_scanpos = xsp;
40080 if (jj_scan_token(354)) {
40081 jj_scanpos = xsp;
40082 if (jj_scan_token(359)) {
40083 jj_scanpos = xsp;
40084 if (jj_scan_token(364)) return true;
40085 }
40086 }
40087 }
40088 }
40089 }
40090 return false;
40091 }
40092
40093 private boolean jj_3R_274() {
40094 if (jj_scan_token(DISASSOCIATE)) return true;
40095 if (jj_scan_token(STATISTICS)) return true;
40096 return false;
40097 }
40098
40099 private boolean jj_3_85() {
40100 if (jj_3R_124()) return true;
40101 if (jj_scan_token(3)) return true;
40102 return false;
40103 }
40104
40105 private boolean jj_3R_273() {
40106 if (jj_scan_token(ASSOCIATE)) return true;
40107 if (jj_scan_token(STATISTICS)) return true;
40108 return false;
40109 }
40110
40111 private boolean jj_3R_187() {
40112 Token xsp;
40113 xsp = jj_scanpos;
40114 if (jj_scan_token(47)) {
40115 jj_scanpos = xsp;
40116 if (jj_scan_token(344)) {
40117 jj_scanpos = xsp;
40118 if (jj_3R_273()) {
40119 jj_scanpos = xsp;
40120 if (jj_scan_token(346)) {
40121 jj_scanpos = xsp;
40122 if (jj_scan_token(75)) {
40123 jj_scanpos = xsp;
40124 if (jj_scan_token(83)) {
40125 jj_scanpos = xsp;
40126 if (jj_3R_274()) {
40127 jj_scanpos = xsp;
40128 if (jj_scan_token(99)) {
40129 jj_scanpos = xsp;
40130 if (jj_scan_token(129)) {
40131 jj_scanpos = xsp;
40132 if (jj_scan_token(357)) {
40133 jj_scanpos = xsp;
40134 if (jj_scan_token(233)) {
40135 jj_scanpos = xsp;
40136 if (jj_scan_token(240)) {
40137 jj_scanpos = xsp;
40138 if (jj_scan_token(365)) {
40139 jj_scanpos = xsp;
40140 if (jj_scan_token(350)) return true;
40141 }
40142 }
40143 }
40144 }
40145 }
40146 }
40147 }
40148 }
40149 }
40150 }
40151 }
40152 }
40153 }
40154 return false;
40155 }
40156
40157 private boolean jj_3R_424() {
40158 if (jj_3R_199()) return true;
40159 return false;
40160 }
40161
40162 private boolean jj_3R_122() {
40163 if (jj_3R_199()) return true;
40164 return false;
40165 }
40166
40167 private boolean jj_3R_502() {
40168 if (jj_scan_token(IS)) return true;
40169 Token xsp;
40170 while (true) {
40171 xsp = jj_scanpos;
40172 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
40173 }
40174 if (jj_3R_405()) return true;
40175 return false;
40176 }
40177
40178 private boolean jj_3R_501() {
40179 if (jj_scan_token(RETURN)) return true;
40180 if (jj_3R_236()) return true;
40181 return false;
40182 }
40183
40184 private boolean jj_3R_500() {
40185 if (jj_3R_386()) return true;
40186 return false;
40187 }
40188
40189 private boolean jj_3_80() {
40190 if (jj_3R_124()) return true;
40191 if (jj_scan_token(3)) return true;
40192 return false;
40193 }
40194
40195 private boolean jj_3R_199() {
40196 if (jj_scan_token(CURSOR)) return true;
40197 if (jj_3R_124()) return true;
40198 Token xsp;
40199 xsp = jj_scanpos;
40200 if (jj_3R_500()) jj_scanpos = xsp;
40201 xsp = jj_scanpos;
40202 if (jj_3R_501()) jj_scanpos = xsp;
40203 xsp = jj_scanpos;
40204 if (jj_3R_502()) jj_scanpos = xsp;
40205 if (jj_scan_token(4)) return true;
40206 return false;
40207 }
40208
40209 private boolean jj_3_84() {
40210 if (jj_3R_122()) return true;
40211 return false;
40212 }
40213
40214 private boolean jj_3R_270() {
40215 if (jj_3R_268()) return true;
40216 return false;
40217 }
40218
40219 private boolean jj_3_83() {
40220 if (jj_3R_121()) return true;
40221 return false;
40222 }
40223
40224 private boolean jj_3_82() {
40225 if (jj_3R_153()) return true;
40226 return false;
40227 }
40228
40229 private boolean jj_3_81() {
40230 if (jj_3R_119()) return true;
40231 return false;
40232 }
40233
40234 private boolean jj_3R_177() {
40235 if (jj_3R_268()) return true;
40236 return false;
40237 }
40238
40239 private boolean jj_3R_563() {
40240 if (jj_3R_183()) return true;
40241 return false;
40242 }
40243
40244 private boolean jj_3R_633() {
40245 if (jj_3R_183()) return true;
40246 return false;
40247 }
40248
40249 private boolean jj_3R_152() {
40250 if (jj_scan_token(6)) return true;
40251 if (jj_3R_124()) return true;
40252 return false;
40253 }
40254
40255 private boolean jj_3R_562() {
40256 if (jj_3R_183()) return true;
40257 return false;
40258 }
40259
40260 private boolean jj_3R_151() {
40261 if (jj_scan_token(6)) return true;
40262 if (jj_3R_124()) return true;
40263 return false;
40264 }
40265
40266 private boolean jj_3R_425() {
40267 if (jj_scan_token(IDENTIFIER)) return true;
40268 return false;
40269 }
40270
40271 private boolean jj_3_76() {
40272 if (jj_3R_124()) return true;
40273 if (jj_scan_token(3)) return true;
40274 return false;
40275 }
40276
40277 private boolean jj_3_79() {
40278 if (jj_3R_124()) return true;
40279 if (jj_scan_token(3)) return true;
40280 return false;
40281 }
40282
40283 private boolean jj_3_75() {
40284 if (jj_scan_token(OF)) return true;
40285 if (jj_3R_124()) return true;
40286 Token xsp;
40287 while (true) {
40288 xsp = jj_scanpos;
40289 if (jj_3R_152()) { jj_scanpos = xsp; break; }
40290 }
40291 return false;
40292 }
40293
40294 private boolean jj_3_74() {
40295 if (jj_scan_token(OF)) return true;
40296 if (jj_3R_124()) return true;
40297 Token xsp;
40298 while (true) {
40299 xsp = jj_scanpos;
40300 if (jj_3R_151()) { jj_scanpos = xsp; break; }
40301 }
40302 return false;
40303 }
40304
40305 private boolean jj_3R_630() {
40306 if (jj_scan_token(3)) return true;
40307 Token xsp;
40308 xsp = jj_scanpos;
40309 if (jj_scan_token(420)) {
40310 jj_scanpos = xsp;
40311 if (jj_scan_token(428)) {
40312 jj_scanpos = xsp;
40313 if (jj_3R_633()) return true;
40314 }
40315 }
40316 return false;
40317 }
40318
40319 private boolean jj_3R_599() {
40320 if (jj_scan_token(9)) return true;
40321 if (jj_scan_token(10)) return true;
40322 return false;
40323 }
40324
40325 private boolean jj_3R_290() {
40326 if (jj_scan_token(PARAMETERS)) return true;
40327 if (jj_3R_564()) return true;
40328 return false;
40329 }
40330
40331 private boolean jj_3R_566() {
40332 Token xsp;
40333 xsp = jj_scanpos;
40334 if (jj_3R_599()) {
40335 jj_scanpos = xsp;
40336 if (jj_scan_token(92)) return true;
40337 }
40338 if (jj_3R_234()) return true;
40339 return false;
40340 }
40341
40342 private boolean jj_3R_526() {
40343 if (jj_scan_token(5)) return true;
40344 if (jj_3R_127()) return true;
40345 if (jj_scan_token(7)) return true;
40346 return false;
40347 }
40348
40349 private boolean jj_3R_289() {
40350 if (jj_scan_token(WITH)) return true;
40351 if (jj_scan_token(CONTEXT)) return true;
40352 return false;
40353 }
40354
40355 private boolean jj_3R_288() {
40356 if (jj_scan_token(NAME)) return true;
40357 Token xsp;
40358 xsp = jj_scanpos;
40359 if (jj_scan_token(420)) {
40360 jj_scanpos = xsp;
40361 if (jj_scan_token(428)) {
40362 jj_scanpos = xsp;
40363 if (jj_3R_563()) return true;
40364 }
40365 }
40366 return false;
40367 }
40368
40369 private boolean jj_3R_267() {
40370 Token xsp;
40371 xsp = jj_scanpos;
40372 if (jj_scan_token(100)) {
40373 jj_scanpos = xsp;
40374 if (jj_scan_token(182)) return true;
40375 }
40376 return false;
40377 }
40378
40379 private boolean jj_3R_528() {
40380 if (jj_scan_token(INDEX)) return true;
40381 if (jj_scan_token(BY)) return true;
40382 if (jj_3R_236()) return true;
40383 return false;
40384 }
40385
40386 private boolean jj_3R_524() {
40387 if (jj_scan_token(6)) return true;
40388 if (jj_3R_522()) return true;
40389 return false;
40390 }
40391
40392 private boolean jj_3R_201() {
40393 Token xsp;
40394 xsp = jj_scanpos;
40395 if (jj_3R_287()) {
40396 jj_scanpos = xsp;
40397 if (jj_3R_288()) {
40398 jj_scanpos = xsp;
40399 if (jj_3R_289()) {
40400 jj_scanpos = xsp;
40401 if (jj_3R_290()) return true;
40402 }
40403 }
40404 }
40405 return false;
40406 }
40407
40408 private boolean jj_3R_287() {
40409 if (jj_scan_token(LIBRARY)) return true;
40410 Token xsp;
40411 xsp = jj_scanpos;
40412 if (jj_scan_token(420)) {
40413 jj_scanpos = xsp;
40414 if (jj_scan_token(428)) {
40415 jj_scanpos = xsp;
40416 if (jj_3R_562()) return true;
40417 }
40418 }
40419 xsp = jj_scanpos;
40420 if (jj_3R_630()) jj_scanpos = xsp;
40421 return false;
40422 }
40423
40424 private boolean jj_3R_523() {
40425 if (jj_scan_token(6)) return true;
40426 if (jj_3R_522()) return true;
40427 return false;
40428 }
40429
40430 private boolean jj_3R_269() {
40431 Token xsp;
40432 xsp = jj_scanpos;
40433 if (jj_scan_token(93)) {
40434 jj_scanpos = xsp;
40435 if (jj_scan_token(144)) {
40436 jj_scanpos = xsp;
40437 if (jj_scan_token(297)) return true;
40438 }
40439 }
40440 return false;
40441 }
40442
40443 private boolean jj_3R_200() {
40444 if (jj_scan_token(LANGUAGE)) return true;
40445 Token xsp;
40446 xsp = jj_scanpos;
40447 if (jj_scan_token(420)) {
40448 jj_scanpos = xsp;
40449 if (jj_scan_token(154)) return true;
40450 }
40451 return false;
40452 }
40453
40454 private boolean jj_3_77() {
40455 if (jj_3R_124()) return true;
40456 if (jj_scan_token(3)) return true;
40457 return false;
40458 }
40459
40460
40461 public PLSQLParserTokenManager token_source;
40462 SimpleCharStream jj_input_stream;
40463
40464 public Token token;
40465
40466 public Token jj_nt;
40467 private Token jj_scanpos, jj_lastpos;
40468 private int jj_la;
40469 private int jj_gen;
40470 final private int[] jj_la1 = new int[460];
40471 static private int[] jj_la1_0;
40472 static private int[] jj_la1_1;
40473 static private int[] jj_la1_2;
40474 static private int[] jj_la1_3;
40475 static private int[] jj_la1_4;
40476 static private int[] jj_la1_5;
40477 static private int[] jj_la1_6;
40478 static private int[] jj_la1_7;
40479 static private int[] jj_la1_8;
40480 static private int[] jj_la1_9;
40481 static private int[] jj_la1_10;
40482 static private int[] jj_la1_11;
40483 static private int[] jj_la1_12;
40484 static private int[] jj_la1_13;
40485 static {
40486 jj_la1_init_0();
40487 jj_la1_init_1();
40488 jj_la1_init_2();
40489 jj_la1_init_3();
40490 jj_la1_init_4();
40491 jj_la1_init_5();
40492 jj_la1_init_6();
40493 jj_la1_init_7();
40494 jj_la1_init_8();
40495 jj_la1_init_9();
40496 jj_la1_init_10();
40497 jj_la1_init_11();
40498 jj_la1_init_12();
40499 jj_la1_init_13();
40500 }
40501 private static void jj_la1_init_0() {
40502 jj_la1_0 = new int[] {0x20000c,0x0,0x0,0x2,0xc,0x200000,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x8,0x0,0x8,0x0,0x0,0x40,0x0,0x0,0x8,0x40,0x8,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x100,0x200,0x200,0x0,0x20,0x0,0x20,0x0,0x40,0x0,0x0,0x0,0x200,0x200,0x4,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x230020,0x0,0x0,0x10,0x30020,0x230020,0x200000,0x30020,0x0,0x0,0x0,0x230020,0x230020,0x230020,0x230020,0x0,0x0,0x1000,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x0,0x0,0x1000,0x30020,0x0,0x30020,0x0,0x0,0x0,0x0,0x0,0x30020,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x20,0x20,0x0,0x0,0x0,0x40,0x40,0x0,0x20,0x0,0x0,0x0,0x40,0x20,0x0,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x20,0x0,0x30020,0x0,0x0,0x30020,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x0,0x8,0x0,0x0,0x2400,0x2400,0xc000,0x8000,0xc000,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x0,0x70000,0x70000,0x40000,0x180002,0x180002,0x30000,0x30020,0x20,0x0,0x20,0x0,0x0,0x0,0x40,0x0,0x20,0x20,0x20,0x40,0x0,0x0,0x20,0x30020,0x0,0x2c,0x0,0x0,0x0,0x808,0x8,0x30020,0x40,0x800000,0x0,0x0,0x0,0x40,0x30000,0x30000,0x40,0x0,0x0,0x40,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x20,0x12,0x0,0x0,0x12,0x0,0x12,0x0,0x0,0x0,0x0,0x0,0x12,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x12,0x0,0x12,0x12,0x40,0x40,0x0,0x20,0x40,0x80,0x0,0x0,0x20,0x40,0x80,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x30000,0x30000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
40503 }
40504 private static void jj_la1_init_1() {
40505 jj_la1_1 = new int[] {0x2008000,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x30,0x800000,0x80000,0xfdfffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x80000,0x52e43c38,0x0,0x2000000,0xfdfffff8,0x80000,0x0,0x0,0xfdfffff8,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x800000,0x30,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2000,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x882000,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x50e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x10000,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000,0x4000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x80000,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x50e43ff8,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x30,0x800000,0x80000,0x80000,0x0,0x0,0x0,0x80000,0x0,0x80000,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x8000,0x0,0x0,0x1000,0x0,0x1000,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x400000,0x400000,0x1000,0x30,0x800000,0x80000,0xfdfffff8,0x0,0xfdfffff8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x8000,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x52e43c38,0x0,0x0,0xfdfffff8,0x0,0x0,0xfdfffff8,0x0,0x8000,0x0,0x8000,0xfdfffff8,0x8000,0x0,0x8000,0x841bc000,0x40e03c30,0xfdfffff8,0x50e43c38,0x79e43ff8,0x28840000,0x0,};
40506 }
40507 private static void jj_la1_init_2() {
40508 jj_la1_2 = new int[] {0x24085c00,0x20001000,0x20001000,0x0,0x4c00,0x0,0x4000000,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x0,0x490000,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x80000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x80,0x7fffffff,0x0,0x80,0x80,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x80000000,0x0,0x0,0xbd71f5b,0x10000000,0x10000000,0x90000,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x0,0x8,0x1,0x8,0x0,0x9000018,0x0,0x0,0x8,0x1,0x0,0x0,0x1000000,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x0,0x20001000,0x0,0x7d71f47,0x27d71f47,0x0,0x3d71f47,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x27d71f47,0x27d71f47,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x3d71f47,0x2d71f43,0x0,0x2d71f43,0x0,0x2d71f43,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbd71f5b,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x3d71f47,0x0,0x1000000,0x2d71f43,0x0,0x3d71f47,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x80,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2d71f43,0x2d75f43,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x7fffffff,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x40000,0x0,0x40000,0x0,0x0,0x2,0x2,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x20000000,0x0,0x20080800,0x0,0x20000000,0x0,0x20080800,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x480000,0x7fffffff,0x0,0x80800,0x0,0x80800,0x7fffffff,0x80800,0x0,0x80800,0x790860a8,0x2d71f43,0x7fffffff,0x2d71f43,0x2bf79f5b,0x9200008,0x0,};
40509 }
40510 private static void jj_la1_init_3() {
40511 jj_la1_3 = new int[] {0x20028008,0x0,0x0,0x0,0x28008,0x0,0x0,0xeefead31,0x1000,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0xeefead31,0x1000,0x0,0xfffffdff,0x0,0x0,0x20800000,0xfffffdff,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x20800000,0x0,0x0,0x0,0x20000000,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0xeefead31,0x0,0x8000,0x0,0xeefead31,0xeefead31,0x0,0x68be2d31,0x0,0x40,0x0,0xeefead31,0xeefead31,0xeefead31,0xeefead31,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x80,0x40,0x0,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x68be2d31,0x0,0x40,0x0,0x400,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x800,0x2,0x2,0x10000000,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x68be2d31,0x0,0x200000,0x68be2d31,0x0,0x68be2d31,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x20000000,0x0,0x20000000,0x20000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0xfffffdff,0x0,0x800000,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x800020,0x800020,0x0,0x0,0x0,0x800000,0x800000,0x8,0x0,0x0,0x0,0xfffffdff,0x0,0xfffffdff,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x8000000,0x8002000,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x0,0x2000000,0x0,0x0,0x8,0x0,0x0,0x0,0x8,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x101,0x101,0x0,0x0,0x0,0x0,0xeefead31,0x0,0x0,0xfffffdff,0x0,0x20000000,0xfffffdff,0x0,0x8,0x0,0x8,0xfffffdff,0x8,0x0,0x8,0x1301404a,0x68be2d31,0xfffffdff,0x68be2d31,0x6dbfadb5,0x1000000,0x0,};
40512 }
40513 private static void jj_la1_init_4() {
40514 jj_la1_4 = new int[] {0x80010002,0x80010000,0x80010000,0x0,0x2,0x0,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x1000000,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x1000000,0x0,0x20000,0xffffdbbd,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x1000000,0x200,0x200,0x2ea6d134,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x20,0x20,0x0,0x20,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0x0,0x80010000,0x0,0x2ea2d1b4,0xaea3d1b4,0x0,0x2ea2d134,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x1000,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x600,0x600,0x0,0x600,0x600,0x0,0x0,0x0,0x0,0x20000000,0x0,0x400000,0x0,0x200,0x200,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x2ea6d134,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x2ea2d134,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x10000200,0x100000,0x0,0x0,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x2ea2d134,0x0,0x200000,0x2ea2d134,0x0,0x2ea2d134,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x2eaad134,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x0,0x4000,0x4000,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x0,0x0,0x1000000,0x0,0x1000000,0x0,0xffffdbbd,0xffffdbbd,0x0,0x20000,0x0,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20020000,0x20020000,0x0,0x0,0x0,0x20000,0x20000,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x0,0xffffdbbd,0x0,0x20000,0x0,0x20000,0x2000,0x0,0x2000,0x0,0x0,0x800000,0x800000,0xffffdbbd,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x10002,0x0,0x10000,0x0,0x10002,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x0,0x0,0xffffdbbd,0x0,0x2,0x0,0x2,0xffffdbbd,0x2,0x0,0x2,0x91550a4b,0x2ea2d134,0xffffdbbd,0x2ea2d134,0x2eaed134,0x240020,0x0,};
40515 }
40516 private static void jj_la1_init_5() {
40517 jj_la1_5 = new int[] {0x20,0x20,0x20,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0x800014,0xffedffff,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x0,0x0,0xfc49ef7f,0x0,0x0,0x800014,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xf800c001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2100,0x2100,0x0,0x2100,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x20,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x4496f7e,0x0,0x4496f7e,0x0,0x4496f7e,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x800000,0x0,0xf0000000,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0xfc49ef7f,0x0,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x64b6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x800000,0x10,0x0,0x10,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x0,0x0,0x800,0x800,0x0,0x6cb6f7e,0x6cb6f7e,0x800000,0x64b6f7e,0x800000,0x0,0x0,0x0,0x0,0x64b6f7e,0x6496f7e,0x64b6f7e,0x0,0x2000000,0x4496f7e,0x0,0x6cb6f7e,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2800000,0x0,0x80000,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x800000,0x800000,0x0,0x4,0x4,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0xffedffff,0x0,0x800014,0x0,0x0,0x2800000,0x800000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x400,0x0,0x0,0x0,0x800014,0x800014,0x0,0x0,0x0,0x800014,0x800014,0x400,0x0,0x0,0x0,0xffedffff,0x0,0xffedffff,0x0,0x2800000,0x800000,0x2000000,0x800000,0x800000,0x800000,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x10000,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0xb901081,0x449677c,0xffedffff,0x4496f7e,0xfc6def7f,0xf800e201,0x0,};
40518 }
40519 private static void jj_la1_init_6() {
40520 jj_la1_6 = new int[] {0xa0020000,0x0,0x0,0x0,0x20000000,0x0,0x0,0xcc2b6392,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x800,0x0,0x0,0x0,0x20000,0x0,0xcc2b6392,0x0,0x0,0xfb9bffbf,0x0,0x4000000,0x80011000,0xff9bffbf,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x800,0x0,0x0,0x0,0x440000,0x0,0x0,0x0,0x0,0x0,0x1000,0xfb9bffbf,0x0,0x1000,0x1000,0x0,0x0,0x0,0x0,0x440000,0x0,0x0,0x4000000,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x440000,0x8000,0x0,0xcb8b6393,0x0,0x0,0x80011000,0x0,0x0,0x0,0x80000000,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0x0,0xc80b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x8000,0x8000,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcb8b6393,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0xc80b6392,0x0,0x0,0x40,0x0,0x40,0xc80b6392,0xc80b6392,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x1000,0x0,0x1000,0x80020000,0x80020000,0x0,0x80020000,0x80020000,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x800,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0x0,0x200,0x200,0x0,0x10000,0x0,0x10000,0x1000,0x1000,0x0,0x0,0x40000,0x400000,0x0,0x0,0x0,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff9bffbf,0xff9bffbf,0x0,0x11000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0x0,0xff9bffbf,0x4000000,0x80000000,0xfb9bffbf,0x0,0x0,0x800,0x0,0xfb9bffbf,0x0,0x0,0x0,0x10101c28,0x880b6192,0xfb9bffbf,0xc80b6392,0xff8be397,0x3800005,0x0,};
40521 }
40522 private static void jj_la1_init_7() {
40523 jj_la1_7 = new int[] {0x25030200,0x5020000,0x5020000,0x0,0x20010000,0x0,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x1000,0x0,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x1000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100008,0x100058,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x25020000,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x2fbeebfc,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x0,0x8000,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x2fbeebfc,0x800000,0x2fbeebfc,0x2bbeebfc,0x0,0x2bbeebfc,0x0,0x2bbeebfc,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x6000,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x4,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x2fbeebfc,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x2fbeebfc,0x0,0x0,0x2bbeebfc,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x2bbeebfc,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x2bbeebfc,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10200,0x0,0x0,0x0,0x10200,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0xbffeebff,0x0,0x10200,0x0,0x10200,0xbffeebff,0x10200,0x0,0x10200,0xe4010409,0x2bbeebf4,0xbffeebff,0x2bbeebfc,0x3bfeebfe,0x22740078,0x0,};
40524 }
40525 private static void jj_la1_init_8() {
40526 jj_la1_8 = new int[] {0x14000020,0x0,0x0,0x0,0x20,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x40,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675f,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x5afd675e,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x4001,0xc0000,0x0,0x0,0x0,0x0,0x1000000,0x80000,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x5afde75f,0x10000100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x10000000,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x8080000,0x5afd675e,0x0,0x5afd675e,0x40000,0x0,0x8080000,0x8000000,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x14000000,0x14000000,0x0,0x14000000,0x14000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x7fffffff,0x7fffffff,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x85029021,0x4afd4742,0x7fffffff,0x5afd675e,0x7efd7fdb,0xfc8001,0x0,};
40527 }
40528 private static void jj_la1_init_9() {
40529 jj_la1_9 = new int[] {0x400002c0,0x40000200,0x40000200,0x0,0xc0,0x0,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0x0,0xffffff71,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xffffff71,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0xc3c0c00,0xf3fbc00,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x10000000,0x10000000,0x20000000,0x10000000,0x40000000,0x40000000,0x0,0xfffdf371,0xfffdf371,0x4,0x40000200,0x0,0xfffdf171,0xfffdf371,0x0,0xfffdf161,0x4,0x0,0x0,0xfffdf371,0xfffdf371,0xfffdf371,0xfffdf371,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x2,0x0,0xfffdf163,0x0,0xfffdf161,0xbffdf161,0x4,0xbffdf161,0x4,0xbffdf161,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0xfffdf161,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0x0,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0xfffdf161,0x0,0x0,0xbffdf161,0x0,0xfffdf161,0x20000000,0x0,0x0,0x0,0x100,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x1,0xffffff71,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0xbffdf161,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x40000e0a,0xbfed7161,0xffffff71,0xbffdf161,0xbffffd71,0xff7ffc00,0x0,};
40530 }
40531 private static void jj_la1_init_10() {
40532 jj_la1_10 = new int[] {0xc7000000,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0xff0000c7,0x0,0x0,0x400,0xff0004c7,0xff0084c7,0xff0084c7,0x2000,0xff0084c7,0xff0084c7,0x1000,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0xff0000c7,0x2000,0x1000,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0xff0004c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0xff0004c7,0xff0000c7,0x0,0xff0000c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x2000,0xff0084c7,0x1000,0xff0084c7,0x8400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x2000,0x1000,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0xff0000c7,0x0,0x0,0xff0000c7,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe,0x0,0x0,0xc7000000,0x0,0x0,0x0,0xc7000000,0x10000000,0xff0000c7,0xc0,0xc0,0x20,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0xe,0x0,0xff0084c7,0xe,0x0,0xff0000cf,0xe,0x0,0xff0000c7,0x6,0xc7000000,0x0,0xc7000000,0xff0000c7,0xc7000000,0x0,0xc7000000,0x300,0xff0000c7,0xff0000c7,0xff0000c7,0xff0000c7,0x1,0x0,};
40533 }
40534 private static void jj_la1_init_11() {
40535 jj_la1_11 = new int[] {0xfa002020,0x0,0x0,0x0,0xfa000000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000000,0x0,0xffffffff,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x4000,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x4004000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x33ac,0x0,0x0,0x0,0x33ac,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x401,0xffffffff,0x0,0x401,0xffffffff,0x0,0x0,0xffffffff,0x0,0x33ac,0x0,0x33ac,0xffffffff,0x2020,0x138c,0x33ac,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x4000000,0x0,};
40536 }
40537 private static void jj_la1_init_12() {
40538 jj_la1_12 = new int[] {0x1f,0x0,0x0,0x0,0x1f,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x18800,0x18800,0x1fc7ffff,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x4000,0x0,0x4000,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x1fc7ffff,0x0,0x0,0x60000,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x100000,0x100000,0x300000,0x80000,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,};
40539 }
40540 private static void jj_la1_init_13() {
40541 jj_la1_13 = new int[] {0x10,0x0,0x0,0x0,0x10,0x0,0x0,0x1630,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x0,0x10,0x1f010,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x0,0x0,0x1630,0x1630,0x0,0x1630,0x0,0x0,0x10,0x1630,0x1630,0x1630,0x1630,0x10,0x0,0x0,0x1630,0x10,0x1630,0x10,0x1630,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x1010,0x0,0x1010,0x0,0x1010,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x1410,0x1410,0x0,0x1410,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1630,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x1630,0x0,0x620,0x1010,0x0,0x1630,0x0,0x0,0x620,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1410,0x1410,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x10,0x1f010,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1010,0x1010,0x1e000,0xe000,};
40542 }
40543 final private JJCalls[] jj_2_rtns = new JJCalls[85];
40544 private boolean jj_rescan = false;
40545 private int jj_gc = 0;
40546
40547
40548 public PLSQLParser(java.io.InputStream stream) {
40549 this(stream, null);
40550 }
40551
40552 public PLSQLParser(java.io.InputStream stream, String encoding) {
40553 try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40554 token_source = new PLSQLParserTokenManager(jj_input_stream);
40555 token = new Token();
40556 token.next = jj_nt = token_source.getNextToken();
40557 jj_gen = 0;
40558 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40559 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40560 }
40561
40562
40563 public void ReInit(java.io.InputStream stream) {
40564 ReInit(stream, null);
40565 }
40566
40567 public void ReInit(java.io.InputStream stream, String encoding) {
40568 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40569 token_source.ReInit(jj_input_stream);
40570 token = new Token();
40571 token.next = jj_nt = token_source.getNextToken();
40572 jjtree.reset();
40573 jj_gen = 0;
40574 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40575 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40576 }
40577
40578
40579 public PLSQLParser(java.io.Reader stream) {
40580 jj_input_stream = new SimpleCharStream(stream, 1, 1);
40581 token_source = new PLSQLParserTokenManager(jj_input_stream);
40582 token = new Token();
40583 token.next = jj_nt = token_source.getNextToken();
40584 jj_gen = 0;
40585 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40586 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40587 }
40588
40589
40590 public void ReInit(java.io.Reader stream) {
40591 jj_input_stream.ReInit(stream, 1, 1);
40592 token_source.ReInit(jj_input_stream);
40593 token = new Token();
40594 token.next = jj_nt = token_source.getNextToken();
40595 jjtree.reset();
40596 jj_gen = 0;
40597 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40598 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40599 }
40600
40601
40602 public PLSQLParser(PLSQLParserTokenManager tm) {
40603 token_source = tm;
40604 token = new Token();
40605 token.next = jj_nt = token_source.getNextToken();
40606 jj_gen = 0;
40607 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40608 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40609 }
40610
40611
40612 public void ReInit(PLSQLParserTokenManager tm) {
40613 token_source = tm;
40614 token = new Token();
40615 token.next = jj_nt = token_source.getNextToken();
40616 jjtree.reset();
40617 jj_gen = 0;
40618 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40619 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40620 }
40621
40622 private Token jj_consume_token(int kind) throws ParseException {
40623 Token oldToken = token;
40624 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40625 else jj_nt = jj_nt.next = token_source.getNextToken();
40626 if (token.kind == kind) {
40627 jj_gen++;
40628 if (++jj_gc > 100) {
40629 jj_gc = 0;
40630 for (int i = 0; i < jj_2_rtns.length; i++) {
40631 JJCalls c = jj_2_rtns[i];
40632 while (c != null) {
40633 if (c.gen < jj_gen) c.first = null;
40634 c = c.next;
40635 }
40636 }
40637 }
40638 return token;
40639 }
40640 jj_nt = token;
40641 token = oldToken;
40642 jj_kind = kind;
40643 throw generateParseException();
40644 }
40645
40646 static private final class LookaheadSuccess extends java.lang.Error { }
40647 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
40648 private boolean jj_scan_token(int kind) {
40649 if (jj_scanpos == jj_lastpos) {
40650 jj_la--;
40651 if (jj_scanpos.next == null) {
40652 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
40653 } else {
40654 jj_lastpos = jj_scanpos = jj_scanpos.next;
40655 }
40656 } else {
40657 jj_scanpos = jj_scanpos.next;
40658 }
40659 if (jj_rescan) {
40660 int i = 0; Token tok = token;
40661 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
40662 if (tok != null) jj_add_error_token(kind, i);
40663 }
40664 if (jj_scanpos.kind != kind) return true;
40665 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
40666 return false;
40667 }
40668
40669
40670
40671 final public Token getNextToken() {
40672 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40673 else jj_nt = jj_nt.next = token_source.getNextToken();
40674 jj_gen++;
40675 return token;
40676 }
40677
40678
40679 final public Token getToken(int index) {
40680 Token t = token;
40681 for (int i = 0; i < index; i++) {
40682 if (t.next != null) t = t.next;
40683 else t = t.next = token_source.getNextToken();
40684 }
40685 return t;
40686 }
40687
40688 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
40689 private int[] jj_expentry;
40690 private int jj_kind = -1;
40691 private int[] jj_lasttokens = new int[100];
40692 private int jj_endpos;
40693
40694 private void jj_add_error_token(int kind, int pos) {
40695 if (pos >= 100) return;
40696 if (pos == jj_endpos + 1) {
40697 jj_lasttokens[jj_endpos++] = kind;
40698 } else if (jj_endpos != 0) {
40699 jj_expentry = new int[jj_endpos];
40700 for (int i = 0; i < jj_endpos; i++) {
40701 jj_expentry[i] = jj_lasttokens[i];
40702 }
40703 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
40704 int[] oldentry = (int[])(it.next());
40705 if (oldentry.length == jj_expentry.length) {
40706 for (int i = 0; i < jj_expentry.length; i++) {
40707 if (oldentry[i] != jj_expentry[i]) {
40708 continue jj_entries_loop;
40709 }
40710 }
40711 jj_expentries.add(jj_expentry);
40712 break jj_entries_loop;
40713 }
40714 }
40715 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
40716 }
40717 }
40718
40719
40720 public ParseException generateParseException() {
40721 jj_expentries.clear();
40722 boolean[] la1tokens = new boolean[434];
40723 if (jj_kind >= 0) {
40724 la1tokens[jj_kind] = true;
40725 jj_kind = -1;
40726 }
40727 for (int i = 0; i < 460; i++) {
40728 if (jj_la1[i] == jj_gen) {
40729 for (int j = 0; j < 32; j++) {
40730 if ((jj_la1_0[i] & (1<<j)) != 0) {
40731 la1tokens[j] = true;
40732 }
40733 if ((jj_la1_1[i] & (1<<j)) != 0) {
40734 la1tokens[32+j] = true;
40735 }
40736 if ((jj_la1_2[i] & (1<<j)) != 0) {
40737 la1tokens[64+j] = true;
40738 }
40739 if ((jj_la1_3[i] & (1<<j)) != 0) {
40740 la1tokens[96+j] = true;
40741 }
40742 if ((jj_la1_4[i] & (1<<j)) != 0) {
40743 la1tokens[128+j] = true;
40744 }
40745 if ((jj_la1_5[i] & (1<<j)) != 0) {
40746 la1tokens[160+j] = true;
40747 }
40748 if ((jj_la1_6[i] & (1<<j)) != 0) {
40749 la1tokens[192+j] = true;
40750 }
40751 if ((jj_la1_7[i] & (1<<j)) != 0) {
40752 la1tokens[224+j] = true;
40753 }
40754 if ((jj_la1_8[i] & (1<<j)) != 0) {
40755 la1tokens[256+j] = true;
40756 }
40757 if ((jj_la1_9[i] & (1<<j)) != 0) {
40758 la1tokens[288+j] = true;
40759 }
40760 if ((jj_la1_10[i] & (1<<j)) != 0) {
40761 la1tokens[320+j] = true;
40762 }
40763 if ((jj_la1_11[i] & (1<<j)) != 0) {
40764 la1tokens[352+j] = true;
40765 }
40766 if ((jj_la1_12[i] & (1<<j)) != 0) {
40767 la1tokens[384+j] = true;
40768 }
40769 if ((jj_la1_13[i] & (1<<j)) != 0) {
40770 la1tokens[416+j] = true;
40771 }
40772 }
40773 }
40774 }
40775 for (int i = 0; i < 434; i++) {
40776 if (la1tokens[i]) {
40777 jj_expentry = new int[1];
40778 jj_expentry[0] = i;
40779 jj_expentries.add(jj_expentry);
40780 }
40781 }
40782 jj_endpos = 0;
40783 jj_rescan_token();
40784 jj_add_error_token(0, 0);
40785 int[][] exptokseq = new int[jj_expentries.size()][];
40786 for (int i = 0; i < jj_expentries.size(); i++) {
40787 exptokseq[i] = jj_expentries.get(i);
40788 }
40789 return new ParseException(token, exptokseq, tokenImage);
40790 }
40791
40792
40793 final public void enable_tracing() {
40794 }
40795
40796
40797 final public void disable_tracing() {
40798 }
40799
40800 private void jj_rescan_token() {
40801 jj_rescan = true;
40802 for (int i = 0; i < 85; i++) {
40803 try {
40804 JJCalls p = jj_2_rtns[i];
40805 do {
40806 if (p.gen > jj_gen) {
40807 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
40808 switch (i) {
40809 case 0: jj_3_1(); break;
40810 case 1: jj_3_2(); break;
40811 case 2: jj_3_3(); break;
40812 case 3: jj_3_4(); break;
40813 case 4: jj_3_5(); break;
40814 case 5: jj_3_6(); break;
40815 case 6: jj_3_7(); break;
40816 case 7: jj_3_8(); break;
40817 case 8: jj_3_9(); break;
40818 case 9: jj_3_10(); break;
40819 case 10: jj_3_11(); break;
40820 case 11: jj_3_12(); break;
40821 case 12: jj_3_13(); break;
40822 case 13: jj_3_14(); break;
40823 case 14: jj_3_15(); break;
40824 case 15: jj_3_16(); break;
40825 case 16: jj_3_17(); break;
40826 case 17: jj_3_18(); break;
40827 case 18: jj_3_19(); break;
40828 case 19: jj_3_20(); break;
40829 case 20: jj_3_21(); break;
40830 case 21: jj_3_22(); break;
40831 case 22: jj_3_23(); break;
40832 case 23: jj_3_24(); break;
40833 case 24: jj_3_25(); break;
40834 case 25: jj_3_26(); break;
40835 case 26: jj_3_27(); break;
40836 case 27: jj_3_28(); break;
40837 case 28: jj_3_29(); break;
40838 case 29: jj_3_30(); break;
40839 case 30: jj_3_31(); break;
40840 case 31: jj_3_32(); break;
40841 case 32: jj_3_33(); break;
40842 case 33: jj_3_34(); break;
40843 case 34: jj_3_35(); break;
40844 case 35: jj_3_36(); break;
40845 case 36: jj_3_37(); break;
40846 case 37: jj_3_38(); break;
40847 case 38: jj_3_39(); break;
40848 case 39: jj_3_40(); break;
40849 case 40: jj_3_41(); break;
40850 case 41: jj_3_42(); break;
40851 case 42: jj_3_43(); break;
40852 case 43: jj_3_44(); break;
40853 case 44: jj_3_45(); break;
40854 case 45: jj_3_46(); break;
40855 case 46: jj_3_47(); break;
40856 case 47: jj_3_48(); break;
40857 case 48: jj_3_49(); break;
40858 case 49: jj_3_50(); break;
40859 case 50: jj_3_51(); break;
40860 case 51: jj_3_52(); break;
40861 case 52: jj_3_53(); break;
40862 case 53: jj_3_54(); break;
40863 case 54: jj_3_55(); break;
40864 case 55: jj_3_56(); break;
40865 case 56: jj_3_57(); break;
40866 case 57: jj_3_58(); break;
40867 case 58: jj_3_59(); break;
40868 case 59: jj_3_60(); break;
40869 case 60: jj_3_61(); break;
40870 case 61: jj_3_62(); break;
40871 case 62: jj_3_63(); break;
40872 case 63: jj_3_64(); break;
40873 case 64: jj_3_65(); break;
40874 case 65: jj_3_66(); break;
40875 case 66: jj_3_67(); break;
40876 case 67: jj_3_68(); break;
40877 case 68: jj_3_69(); break;
40878 case 69: jj_3_70(); break;
40879 case 70: jj_3_71(); break;
40880 case 71: jj_3_72(); break;
40881 case 72: jj_3_73(); break;
40882 case 73: jj_3_74(); break;
40883 case 74: jj_3_75(); break;
40884 case 75: jj_3_76(); break;
40885 case 76: jj_3_77(); break;
40886 case 77: jj_3_78(); break;
40887 case 78: jj_3_79(); break;
40888 case 79: jj_3_80(); break;
40889 case 80: jj_3_81(); break;
40890 case 81: jj_3_82(); break;
40891 case 82: jj_3_83(); break;
40892 case 83: jj_3_84(); break;
40893 case 84: jj_3_85(); break;
40894 }
40895 }
40896 p = p.next;
40897 } while (p != null);
40898 } catch(LookaheadSuccess ls) { }
40899 }
40900 jj_rescan = false;
40901 }
40902
40903 private void jj_save(int index, int xla) {
40904 JJCalls p = jj_2_rtns[index];
40905 while (p.gen > jj_gen) {
40906 if (p.next == null) { p = p.next = new JJCalls(); break; }
40907 p = p.next;
40908 }
40909 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
40910 }
40911
40912 static final class JJCalls {
40913 int gen;
40914 Token first;
40915 int arg;
40916 JJCalls next;
40917 }
40918
40919 }